﻿///<jscompress sourcefile="NW00.js" />
/**
 * 模块缓存、管理
 * 在启动本脚 附值。  nw.mk.GNMK = _nw_zcMKJG;
 */
function NW00() {
    //功能模块
    this.GNMK = [];

}

//用于缓存的 对象格式
function NW00_gt(sfz, dx) {
    this.sfz = sfz; //用于作索引的。
    this.gt = dx;   //用户主要的缓存数据。数组、对象、数字、文本.........
}



/**
 * 通过模块【对象】身份证，取得模块对象。
 * @param {文本} sfz 身份证
 * @returns 对象
 */
NW00.prototype.hqMK = function (sfz) {
    for (let i = 0; i < this.GNMK.length; i++) {
        if (this.GNMK[i]._xt_sfz == sfz) {
            return this.GNMK[i];
        }
    }
    return null;
}

/**
 * 通过模块【对象】身份证，删除模块对象。
 * @param {文本} sfz 身份证
 */
NW00.prototype.scMK = function (sfz) {

    for (let i = 0; i < this.GNMK.length; i++) {
        if (this.GNMK[i]._xt_sfz == sfz) {
            this.GNMK.splice(i, 1);
        }
    }
};
///<jscompress sourcefile="_tzWMK.js" />
// 【碎片】拓展模块对象方法

/**
 * 获取所有-拓展模块对象
 * @param {文本} sfz 身份证
 * @returns [对象,...N对象]
 */
NW00.prototype.hqTZmk = function () {
    let _TZsz = [];
    let _dx;
    for (let i = 0; i < this.GNMK.length; i++) {
        _dx = this.GNMK[i];
        if (_dx._xt_pz && _dx._xt_pz.tzff) {
            _TZsz.push(_dx);
        }
    }
    return _TZsz;
}


/**
 * 取得 1个模块对象 配置的 ，要被拓展的 对象列表（[对象,....对象n]
 * @param {对象} mk 模块
 * @returns 数组
 */
NW00.prototype.hqTZmkPZ_dxSZ = function (mk) {
    return mk._xt_pz.tzff;
}

/**
 * 取得 提供方法给_tzDX的对象  【路径】
 * @param {对象} _tzDX 模块对象里面，配置的列表中的 1个对象
 * @returns 文本，路径
 */
NW00.prototype.hqTZmkPZ_lj = function (_tzDX) {
    // 当配置里没有指定 dx，默认就是mk本身。
    return _tzDX.lj;
}

/**
 * 取得 被拓展方法的对象。
 * 
 * @param {对象} mk  模块对象
 * @param {对象} _tzDX  模块对象里面，配置中的 1个对象
 * @returns 对象
 */
NW00.prototype.hqTZmkPZ_dx = function (mk, _tzDX) {
    // 当配置里没有指定 dx，默认就是mk本身。
    return _tzDX.dx ? _tzDX.dx : mk;
}
;
///<jscompress sourcefile="NW01.js" />
/**
 * 工具类
 */
function NW01(){
};
///<jscompress sourcefile="_dx.js" />
// 基础工具-对象。对现成的浏览器对象，进行管理。比如，XMLHttpRequest 获取。
/**
 * 判断zhi是否 对象
 * @参数 {任意} zhi  数据源
 * @返回 true：zhi是对象；false：zhi不是对象
 */
NW01.prototype.pdD = function (zhi) {
	return typeof zhi == 'object';
}

/**
 * 【工具】
 * 取得 封装节点样式的 处理对象。
 * @参数 {对象} Jiedian 节点
 */
NW01.prototype.hqYangshi = function (Jiedian) {
	return window.getComputedStyle ?
		window.getComputedStyle(Jiedian, null) :
		Jiedian.currentStyle;
}

/**
 * 取得 XMLHttpRequest 对象
 */
NW01.prototype.hqXMLHttpRequest = function () {
	let xmlhttp;
	if (window.XMLHttpRequest) {
		//  IE7+, Firefox, Chrome, Opera, Safari 浏览器执行代码
		xmlhttp = new XMLHttpRequest();
	} else {
		// IE6, IE5 浏览器执行代码
		xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
	}
	return xmlhttp;
}

/**
 * 对象转成文本
 * @param {对象} dx 对象
 * @param {文本} ljf_sx 连接符。 属性之间的连接符。默认为 &
 * @param {文本} ljf_m_z 连接符。  属性【名】、属性【值】 之间的连接符。默认为 =
 */
NW01.prototype.dx_z_wb = function (dx, ljf_sx, ljf_m_z) {
	// {a=11,c=123}  : "a=11&c=123"
	if (!ljf_sx) {
		ljf_sx = "&";
	}
	if (!ljf_m_z) {
		ljf_m_z = "=";
	}

	let _jg; //用于拼接字符串
	let _kaishi = true; //开关
	for (let ming in dx) {
		if (_kaishi) {
			_jg = ming + ljf_m_z + dx[ming];
			_kaishi = false;
			continue;
		}
		_jg += ljf_sx + ming + ljf_m_z + dx[ming];
	}

	return _jg;
}
;
///<jscompress sourcefile="_gn.js" />
/**
 *获取 滚动条厚度
 * @returns {数字} 滚动条厚度
 */
NW01.prototype.hqXGDTGao_YGDTKuan = function () {
	let _RQ = document.createElement("div");
	_RQ.style.position = "absolute";
	_RQ.style.width = "30px";
	_RQ.style.height = "30px";
	_RQ.style.top = "-99px";
	_RQ.style.overflow = "scroll";
	document.body.appendChild(_RQ);
	let _kuan1 = _RQ.offsetWidth;
	let _GDT = document.createElement("div");
	_GDT.style.width = "100%";
	_RQ.appendChild(_GDT);
	let _kuan2 = _GDT.offsetWidth;
	document.body.removeChild(_RQ);
	return _kuan1 - _kuan2;
}

/**
 * 停止 浏览器弹出右键菜单
 */
NW01.prototype.tzLLQ_youjiCaidan = function () {
	window.oncontextmenu = function () {
		return false
	};
}

/**
 * 格式化文本(gsh),将文本转化成 Json对象（最终目标mb)
 * @参数 {对象} text 文本
 */
NW01.prototype.gshWB_mbJson = function (text) {
	if (null == text || text == '') {
		return null;
	}
	let obj = new Function('return ' + text)();
	return obj;
};
///<jscompress sourcefile="_jd.js" />

/**
 * 获取节点
 * @param {文本|nw节点对象|其他-直接返回} JD 文本=主键；nw=JD.Jiedian；其他=return 其他；
 * @returns 原始节点对象
 */
NW01.prototype.hqJD = function (zhi) {
    if (typeof zhi == 'string') {
        return document.getElementById(zhi);
    }
    else if (zhi.Jiedian) {
        return zhi.Jiedian;
    } else {//传入的是普通的节点的对象
        return zhi;
    }
}



/**
 * 获取(hq)一个节点(Jiedian)内容（NeiRong) 对象里面的 内容(neiRong)
 * 
 * @参数 {对象} Jiedian 节点
 * @返回 {文本} 节点的【内容对象】的内容
 */
NW01.prototype.hqNR = function (Jiedian) {
    let _WB = this.hqNRjd(Jiedian);
    if (_WB) {
        return _WB.nodeValue;
    }
    return '';
}
/**
 * 获取(hq)一个节点(Jiedian)内容（NeiRong)
 * 
 * @参数 {id|dom/nw对象} Jiedian 节点
 * @返回 {对象} 节点的【内容对象】
 */
NW01.prototype.hqNRjd = function (Jiedian) {
    let _JD = this.hqJD(Jiedian);
    let _Erzim = _JD.childNodes; //取出所有的子节点。
    if (_Erzim.length == 0) { //没有子节点，
        return null; //返回null
    }
    //开始找 文本节点。
    for (let i = 0; i < _Erzim.length; i++) {
        if (_Erzim[i].nodeType == 3) { //找到文本节点。
            return _Erzim[i]; //返回 文本节点。
        }
    }
    //没有找到文本节点，返回null
    return null;
}
/**
 * 取节点的所有（包含它的所有下游 文本对象 ）文本对象 
 * @返回 {*} Jiedian 节点
 * @返回 {*} WenbenJiedianS 数组-存放 文本对象 的结果容器
 * @返回 {真|假} pdGuolvHHF 是否过滤 换行符号(HHF); true=过滤；false=不过滤
 */
NW01.prototype.hqNRjdM = function (Jiedian, _JG, pdGuolvHHF) {
    let _JD = this.hqJD(Jiedian);
    //取出所有的子节点
    let Erzim = _JD.childNodes;
    if (Erzim.length == 0) { //没有子节点，
        return null; //返回null
    }
    let _WB;
    //开始找 文本节点。
    for (let i = 0; i < Erzim.length; i++) {
        if (Erzim[i].nodeType == 3) { //找到文本节点。
            _WB = Erzim[i]; //返回 文本节点。
            if (_WB.nodeValue) {
                if (pdGuolvHHF) {
                    _WB.nodeValue = _WB.nodeValue.replace(/[\r\n]/g, "");
                }
                _JG.push(_WB);
            }
            continue;
        } else {
            this.hqNRjdM(Erzim[i], _JG, pdGuolvHHF);//递归
        }
    }
}

/**
 * 删除 (sc)一个节点(Jiedian)内容（NeiRong)
 * 
 * @参数 {对象} Jiedian 节点
 */
NW01.prototype.scNRjd = function (Jiedian) {
    let _WB = this.hqNRjd(Jiedian);
    if (_WB) {
        Jiedian.removeChild(_WB);
    }
}
/**
 * 判断父子关系
 * 如果两个节点是父子节点。那么,返回true。其情况情况，一键是false
 * @参数 {对象} father 父节点
 * @参数 {对象} son 子节点
 * @参数 {boolean} fuDengYuZi 是否父子节点相同（同个节点） true=允许；false=不允许 
 */
NW01.prototype.pdFuzi = function (Fu, Zi, fuDengYuZi) {
    if (!Fu || !Zi) {
        return false;
    }
    let _F = this.hqJD(Fu);
    let _Z = this.hqJD(Zi);
    if (fuDengYuZi && _F == _Z) {
        return true;
    }
    if (_F = _Z.parentNode) {
        return true;
    }
    return false; //找不到。证明不是row节点里面的节点。或不是单元格。
}
//------------↑↑↑↑↑【节点-父子关系】↑↑↑↑↑------------


/**
 * 判断Shang是否是Xia的上游.是返回true；否返回false
 * 
 * 如果Shang等于Xia，也返回true;
 * @参数 {对象} Shang 上游原始节点
 * @参数 {对象} Xia 下游原始节点
 * @参数 {真假} ShangDengYuXia 是否允许 上游等于下游
 * 
 * @返回 判断结果
 */
NW01.prototype.pdShangxiaYou = function (Shang, Xia, shangDengyuXia) {
    if (!Shang || !Xia) {
        return false;
    }
    let _S = this.hqJD(Shang);
    let _X = this.hqJD(Xia);
    if (!_S || !_X) {
        return false;
    }
    if (shangDengyuXia && _S == _X) {
        return true;
    }
    while (_X = _X.parentNode) {
        if (_X == _S) {
            return true;
        }
    }
    return false;
}

//------------↓↓↓↓↓【创建节点】↓↓↓↓↓------------
/**
 * 创建一个节点
 * @参数 {文本} bqMing 节点标签。如果没有指明标签符号，默认是 div
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian = function (bqMing, SXdx) {
    let _JD = document.createElement(bqMing ? bqMing : 'div');
    if (SXdx) {
        let _zhi;
        let _SX;
        for (let ming in SXdx) { 					//_ysYB：样式游标 的意思。
            _zhi = SXdx[ming];
            _SX = document.createAttribute(ming); 	//创建一个新的属性
            if (_zhi != null) {
                _SX.value = _zhi;					//设置属性值
            }
            _JD.setAttributeNode(_SX); 				//加入属性到节点里
        }
    }
    return _JD;
}

/**
 * 创建一个div节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_div = function (SXdx) {
    return this.cjJiedian('div', SXdx);
}

/**
 * 创建一个a节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_a = function (SXdx) {
    return this.cjJiedian('a', SXdx);
}

/**
 * 创建一个span节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_span = function (SXdx) {
    return this.cjJiedian('span', SXdx);
}

/**
 * 创建一个input节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_input = function (SXdx) {
    return this.cjJiedian('input', SXdx);
}

/**
 * 创建一个select节点
 * 
 * @参数 {数组} xxS 选项列表 对象 数组;  数组[{ming:'xxxxxx' ,zhi:'ssssss'}]
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_select = function (xxS, morenzhi, SXdx) {
    //创建一个选择节点
    let _JD = this.cjJiedian('select', SXdx);
    let _JDxx;
    if (xxS) {
        for (let i = 0; i < xxS.length; i++) {
            _JDxx = document.createElement("option");
            _JDxx.value = xxS[i].zhi;
            _JDxx.text = xxS[i].ming;
            if (morenzhi == xxS[i].zhi) {
                _JDxx.selected = true;
            }
            _JD.add(_JDxx);
        }
    }
    return _JD;
}
//------------↑↑↑↑↑【创建节点】↑↑↑↑↑------------

/**
 * 取 Jiedian 节点及其他下游所有节点的 【模板属性——即，属性值带着占位符的】 属性对象
 * @返回 {对象} Jiedian 节点
 * @返回 {数组} SXJiedianS 数组-存放 发展对象 的结果容器
 */
NW01.prototype.hqMBsxM = function (Jiedian, SXJiedianS) {
    let _ShuxingS = Jiedian.attributes;//节点的所有属性;
    //判断 所有的属性值，是否包括 模板符号。
    if (_ShuxingS) {
        for (let i = 0; i < _ShuxingS.length; i++) {
            if (_ShuxingS[i].value.indexOf("}") != -1) {	//如果此属性值包含模板符号
                SXJiedianS.push(_ShuxingS[i]);		//缓存属性
            }
        }
    }
    //取出所有的子节点
    let Erzim = Jiedian.children;
    if (Erzim.length == 0) { //没有子节点，
        return;
    }
    //取出每一个子节点的 所有属性
    for (let i = 0; i < Erzim.length; i++) {
        this.hqMBsxM(Erzim[i], SXJiedianS);//递归
    }
}

/**
 * 设置复选框状态
 * zhi== null         表示取反
 * zhi== false        表示全部不勾选
 * zhi== true         表示全部勾选
 * zhi=='1,2'         表示只对选框值为1、2的两个选框，设置zt状态。 其他 (!zt) 状态
 * 
 * @param {文本}        mc 节点名
 * @param {文本|数字}   zhi 
 * @param {真|假}       zt 
 */
NW01.prototype.szZT_fxk = function (mc, zhi, zt) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    // zhi= null         表示取反
    if (zhi == null) {
        for (let i = 0; i < jdm.length; i++) {
            jdm[i].checked = !jdm[i].checked
        }
        return;
    }
    let _zjzhi = typeof zhi == 'boolean';
    //zhi=false 表示全部不勾选
    if (_zjzhi && !zhi) {
        this._ngj_szZT_fxk(jdm, false);
        return;
    }
    //zhi=true  表示全部勾选
    if (_zjzhi && zhi) {
        this._ngj_szZT_fxk(jdm, true);
        return;
    }
    zt = zt ? true : false;
    let zt2 = !zt;
    if (typeof zhi == 'number') {
        zhi += ''
    } else {
        zhi = NWHS_sck(zhi);
    }
    //全部取反状态
    this._ngj_szZT_fxk(jdm, zt2);
    // for (let j = 0; j < jdm.length; j++) {
    //     jdm[j].checked = zt2;
    // }
    //zhi='1' 
    if (zhi.indexOf(',') == -1) {
        for (let i = 0; i < jdm.length; i++) {
            if (jdm[i].value == zhi) {
                jdm[i].checked = zt
                return;
            }
        }
    }
    // zhi='1,2'
    let zhiM = zhi.split(',');
    for (let i = 0; i < zhiM.length; i++) {
        zhiM[i] = NWHS_sck(zhiM[i])//除空选
    }
    //符合值的，取zt状态
    for (let j = 0; j < jdm.length; j++) {
        zhi = NWHS_sck(jdm[j].value);//取节点的value值
        for (let i = 0; i < zhiM.length; i++) {
            if (zhi == zhiM[i]) {   //  判断 节点.value == 用户的值（切割出来的）
                jdm[j].checked = zt;
                break
            }
        }
    }
}

NW01.prototype._ngj_szZT_fxk = function (fxkM, zt) {
    for (let i = 0; i < fxkM.length; i++) {
        fxkM[i].checked = zt
    }
}

/**
 * 获取 xx状态的复选框的值
 * @param {文本} mc 节点名
 * @param {真假} zt 状态
 * @param {真假} szfzJG 返回的结果，是否以数组形式返回。真=数组形式 ['q','w','e'] ， 假=文本方式。'a,b,d,c'
 */
NW01.prototype.hqZT_fxk_dxk = function (mc, zt, szfzJG) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    zt = zt ? true : false;

    let sz = szfzJG ? true : false;
    let jg = sz ? [] : '';

    for (let i = 0; i < jdm.length; i++) {
        if (jdm[i].checked == zt) {
            if (sz) {
                jg.push(jdm[i].value)
            } else {
                if (jg) {
                    jg += ','
                }
                jg += jdm[i].value;
            }
        }
    }
    return jg;
}


/**
 * 设置单选框状态
 * zhi== 假值||zt==假值        表示全部不勾选
 * zhi=='1'          表示只对选框值为1的两个选框，设置zt状态。 其他 (!zt) 状态
 * 
 * @param {文本}        mc 节点名
 * @param {文本|数字}   zhi 
 * @param {真|假}       zt 
 */
NW01.prototype.szZT_dxk = function (mc, zhi, zt) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    zt = typeof zt == 'string' ? new Boolean(zt) : (zt ? true : false);
    // zhi== 假|null ||zt==假值        表示全部不勾选
    let zhilx = typeof zhi;
    if (null == zhi || (zhilx == 'boolean' && !zhi) || !zt) {
        this._ngj_szZT_fxk(jdm, false);
        return;
    }
    if (zhilx == 'number') {
        zhi += ''
    } else {
        zhi = NWHS_sck(zhi);
    }
    //zhi='1' 
    // console.log(zhi + '//' + zt)
    for (let i = 0; i < jdm.length; i++) {
        if (jdm[i].value == zhi) {
            jdm[i].checked = zt
            return;
        }
    }
}
;
///<jscompress sourcefile="_jt.js" />
//------------↓↓↓↓↓【事件——监听】↓↓↓↓↓------------
/**
 * 监听
 * @参数 {节点对象} Jiedian
 * @参数 {事件key} daihao 事件代号
 * @参数 {函数} ff 事件触发时，自动调用的函数
 * @参数 {布尔值} useCapture 可选。布尔值，指定事件是否 在捕获或冒泡阶段执行。
 *  false- 默认。事件句柄在冒泡阶段执行.
 *  true - 事件句柄在捕获阶段执行
 */
NW01.prototype.jt = function (Jiedian, daihao, ff, useCapture) {
    Jiedian.addEventListener(daihao, ff, useCapture);
}
//------------↑↑↑↑↑【事件——监听】↑↑↑↑↑------------;
///<jscompress sourcefile="_nr.js" />
// 基础工具-内容


/**
 * 【工具】
 * 【只留数字】——所有非数据类的，都会被剔除。然后,转成float型数字，并返回出去。
 * @参数 {文本} yuan 源字符串。
 * @参数 {真假} pdInt  是否返回int类型的值；默认否（返回float); 为true时，返回int类型的结果。
 * @返回 {int|float} 数值
 */
NW01.prototype.zlShuzi = function (yuan, pdInt) {
    if (yuan) {
        let _WenbenShuzuS = yuan.split('');//文本数组
        let _Rongqi = '';//容器
        for (let i = 0; i < _WenbenShuzuS.length; i++) {
            if (_WenbenShuzuS[i] == '-' || _WenbenShuzuS[i] == '1' || _WenbenShuzuS[i] == '2' || _WenbenShuzuS[i] == '3' || _WenbenShuzuS[i] == '4' || _WenbenShuzuS[i] == '5' ||
                _WenbenShuzuS[i] == '6' || _WenbenShuzuS[i] == '7' || _WenbenShuzuS[i] == '8' || _WenbenShuzuS[i] == '9' || _WenbenShuzuS[i] == '0' || _WenbenShuzuS[i] == '.')
                _Rongqi += _WenbenShuzuS[i];
        }
        return pdInt ? parseInt(_Rongqi) : parseFloat(_Rongqi);
    }
    return 0;
}

/**
 * 判断zhi是否 文本
 * @参数 {任意} zhi 数据源
 * @返回 true=是文本；false=不是文本
 */
NW01.prototype.pdWenben = function (zhi) {
    return typeof zhi == 'string';
}

// /**
//  * 格式化地址（DiZhi)参数(canshu),使其变成"参数1=1&参数2=xx............"的格式。
//  * @参数 {String|Object} dizhiShuju 路径参数
//  */
// NW01.prototype.gshDiZhi_canshu = function (dizhiShuju) {
//     if (null == dizhiShuju || undefined == dizhiShuju) {
//         return '';
//     }
//     //传入来的是字符串时
//     if (this.pdWenben(dizhiShuju)) {
//         return this.scKong(dizhiShuju);
//     }
//     //不是字符串,就是对象（框架锁定 逻辑）。所以，进行对象的键值对的提取中。
//     let str; //用于拼接字符串
//     let forFirst = true; //开关
//     for (let key in dizhiShuju) {
//         if (forFirst) {
//             str = key + "=" + dizhiShuju[key];
//             forFirst = false;
//             continue;
//         }
//         str = str + '&' + key + "=" + dizhiShuju[key];
//     }
//     return str;
// }

/**
 *【工具】
 * 除去字符串两端的空(Kong)。
 * @参数 {文本} yuan 源字符串
 * @返回 {文本} 去除两边空格后的 字符串
 */
NW01.prototype.scKong = function (yuan) {
    return NWHS_sck(yuan)
}


/**
 * 专为属性名定制 "  g ao" =>  "gao" 
 * @param {文本} ming 属性名
 * @returns 没有空的 属性名
 */
NW01.prototype.gshSXM = function (ming) {
    let _m = '';
    if (ming) {
        let _NR = ming.split('');//源数组
        for (let i = 0; i < _NR.length; i++) {
            if (_NR[i] != ' ') {
                _m += _NR[i];
            }
        }
    }
    return _m;
}

/**
 * 产生随机数[zx,zd]; 默认是[0,100]
 * @param {整数} zx 最小值
 * @param {整数} zd 最大值
 * @returns 整数-随机数
 */
NW01.prototype.hqSJS_zs = function (zx, zd) {
    if (null == zx) {
        zx = 0;
    }
    if (null == zd) {
        zd = 100;
    }
    return parseInt(Math.random() * (zd - zx + 1) + zx, 10);
}


NW01.prototype.jiamiNR = function (nr, bysj) {
    if (null == bysj) {
        bysj = 3;
    }
    let _sjs = this.hqSJS_zs();
    let _jg = "" + (_sjs - bysj)//保存
    nr = nr.split('');
    for (let i = 0; i < nr.length; i++) {
        _jg += ' ' + (nr[i].charCodeAt() - _sjs)
    }
    return _jg;
}

NW01.prototype.jiemiNR = function (nr, bysj) {
    if (!nr) {
        return nr;
    }
    if (null == bysj) {
        bysj = 3;
    }
    nr = nr.split(' ');
    let _sjs = parseInt(nr[0]) + bysj;
    let _jg = ''

    for (let i = 1; i < nr.length; i++) {
        _jg += String.fromCharCode(parseInt(nr[i]) + _sjs)
    }
    return _jg;
}


;
///<jscompress sourcefile="NW02_gj.js" />
/**
 * DOM对象封装  工具
 */
function NW02_gj(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
}

// NW02_gj.prototype.hqYangshi = function (Jiedian) {
//     return window.getComputedStyle ? window.getComputedStyle(Jiedian, null) : Jiedian.currentStyle;
// }


// /**
//  * 获取节点
//  * @param {文本|nw节点对象|其他-直接返回} JD 文本=主键；nw=JD.Jiedian；其他=return 其他；
//  * @returns 原始节点对象
//  */
// NW02_gj.prototype.hqJD = function (zhi) {
//     if (typeof zhi == 'string') {
//         return document.getElementById(zhi);
//     }
//     else if (zhi.Jiedian) {
//         return zhi.Jiedian;
//     } else {//传入的是普通的节点的对象
//         return zhi;
//     }
// };
///<jscompress sourcefile="NW02_jd.js" />
/**
 * DOM对象封装  节点
 */
function NW02_jd(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.gj = fq.gj;
    this.wgj = fq.wgj;
    this.Jiedian = fq.Jiedian;
}


;
///<jscompress sourcefile="_Erzi.js" />
/**
 * 向本节点添加一个子节点 JDian
 * @参数 {对象}  被添加的子节点  JDian
 */
NW02_jd.prototype.tjEZ = function (JD) {
    if (JD) {
        let _Erzi = this.wgj.hqJD(JD);
        if (_Erzi) {
            this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
        }
    }
}

/**
 * 创建一个子节点
 * @参数 {文本} ysBQ 节点标签。如果没有指明标签符号，默认是 div
 * @返回 {对象} 子节点
 */
NW02_jd.prototype.cjEZ = function (ysBQ, SXdx) {
    let _Erzi = this.wgj.cjJiedian(ysBQ, SXdx);//创建一个节点
    this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
    return _Erzi;
}

/**
 * 创建一个子节点_下拉列表（复选框）
 * 
 * @参数 {数组} xxS 选项列表 对象 数组;  数组[{ming:'xxxxxx' ,zhi:'ssssss'}]
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW02_jd.prototype.cjEZ_xllb = function (xxS, morenzhi, SXdx) {
    // let _Erzi = this.cjJiedian(ysBQ, SXdx);//创建一个节点
    let _Erzi = this.wgj.cjJiedian_select(xxS, morenzhi, SXdx);
    this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
    return _Erzi;
}

/**
 * 删除一个子节点
 * @参数 {正数|文本|对象} yb_Id_erzi 子节点或其id或其在所有的儿子们中，排的顺序（从0开始算，不计文本节点）
 */
NW02_jd.prototype.scEZ = function (yb_Id_erzi) {
    if (!yb_Id_erzi) {
        return;
    }
    switch (typeof yb_Id_erzi) {
        case 'object':
            this.Jiedian.removeChild(yb_Id_erzi);
            break;
        case 'number':
            this.Jiedian.removeChild(this.hqEZ_tgYB(yb_Id_erzi));
            break;
        case 'string':
            this.Jiedian.removeChild(this.wgj.hqJD(yb_Id_erzi));
            break;
    }
}

/**
 * 通过 【子节点游标】，直接找到子节点。不包含文本节点
 * @参数 {对象} yb 子节点 游标（在所在儿子们那里，它排在第几位——从0开始算）
 * @返回 {对象} 子节点
 */
NW02_jd.prototype.hqEZ_tgYB = function (yb) {
    let _ErziM = this.hqEZm_feiWB(); //不包含文本节点的 子节点集合
    if (_ErziM.length == 0) {
        return null;
    }
    for (let i = 0; i < _ErziM.length; i++) {
        if (i == yb) {
            return _ErziM[i];
        }
    }
    return null;

}

/**
 * 取得子节点Erzi 在本节点的子节点集合中,它的顺序.
 * 备注:不包含[文本节点]
 * 
 * @参数 {对象} Erzi 普通\nw节点，子节点
 * 
 * @返回 {int} Erzi在父类的子节点集合的游标 .
 */
NW02_jd.prototype.hqEZyb = function (Erzi) {
    if (!Erzi) { //如果不为真值,直接返回-1
        return -1;
    }
    let _Ez = Erzi.Jiedian ? Erzi.Jiedian : Erzi;
    let _ErziM = this.hqEZm_feiWB(); //取得所有非文本的子节点
    if (_ErziM.length == 0) {
        return -1;
    }
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i] == _Ez) {
            return i;
        }
    }
    return -1;
}

/**
 * 获取(hq)节点的所有儿子(不算文本节点在内)
 * 
 * @返回 {数组} 节点的儿子们
 */
NW02_jd.prototype.hqEZm_feiWB = function () {
    return this.Jiedian.children;
}

/**
 * 获取(hq)节点的所有儿子
 * 
 * @返回 {数组} 节点的儿子们
 */
NW02_jd.prototype.hqEZm = function () {
    return this.Jiedian.childNodes;
}

/**
 * 节点移动
 * 正数右移,负数左移.
 * 假设数组[a,b,1,2,3],参数Erzi="b",数组下标=1
 * 假设shunXu=2   ,b向右移动2个格子,移动后的数组:[a,1,2,b,3]
 * 假设shunXu=-1  ,b向左移动1个格子.移动后的数组:[b,a,1,2,3]
 * 
 * @参数 {对象} Erzi 子节点
 * @参数 {对象} shunXu 正数,表示离0位越远_向右移到shunXu格子;负数,表示离0位越近,向左移
 */
NW02_jd.prototype.ydEZ_tgSX = function (Erzi, shunXu) {
    if (!Erzi || shunXu == 0) {
        return;
    }
    let _EZ = this.wgj.hqJD(Erzi);
    if (!_EZ) {
        return;
    }
    let _ErziM = this.hqEZm_feiWB();
    let _yb = this.hqEZyb(_EZ); //取得son的下标.
    if (_yb == null) {
        return; //末知的坐标.假值 
    }
    let sonArr = []; //临时数组
    let sonArrIndex = 0; //sonArr的临时下标 .
    //右移
    if (shunXu > 0) {
        //1假设son原本位置在1,shunXu=2; 那么,移后的位置应该是 1+2=3;
        _yb = _yb + shunXu;
        //2假设数组最大下标为2;如[a,son,b],那么,下标3已经超出我们的数组的范围.
        if (_yb > _ErziM.length - 1) { // sons.length - 1 就是假定数组的 最大下标.
            _yb = _ErziM.length - 1; //数组的长度3,下标最大限制值是2 因为,下标是从0开始计算.
        }
    } else { //进入else,条件必定是:shunXu < 0   左移
        //假设数组[a,b,c,son,d,e]
        //1假设son原本位置在3,shunXu=-2; 那么,移后的位置应该是 3+(-2)=1;
        _yb = _yb + shunXu; //假设shunXu=-4时,很明显,3+(-4)=-1!明显超出数组的范围.所以
        if (_yb < 0) { //如果超出顶部位置,锁定其位置为0;
            _yb = 0;
        }
    }
    sonArr[_yb] = _EZ; //排好son的新位置
    // console.log('son=' + son['id'] + '计算后的位置是:' + index);
    //排序.
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i] == _EZ) {
            continue; //son已经放到 sonArr[index]中去了.
        }
        if (_yb == sonArrIndex) { //如果数组已经有值,下标 下移一位.
            sonArrIndex++;
        }
        sonArr[sonArrIndex++] = _ErziM[i];
    }
    //按排序好的顺序,不断追加到父节点.如果父节点已经有这个子节点,会自动删除后,再追加
    for (let i = 0; i < sonArr.length; i++) {
        this.tjEZ(sonArr[i]);
    }
    sonArr.length = 0; //数组回收
    return;
}

// 'name=wang'
NW02_jd.prototype.hqEZ_tgTJ = function () {

};
///<jscompress sourcefile="_Jiedian.js" />
//------------↓↓↓↓↓【删除节点】↓↓↓↓↓------------
/**
 * 删除本节点
 */
NW02_jd.prototype.sc = function () {
    let FJiedian = this.Jiedian.parentNode; //取节点父亲
    if (FJiedian) {
        FJiedian.removeChild(this.Jiedian); //删除父亲的子节点——Jiedian；
    }
}
//获取节点 符号
NW02_jd.prototype.hqJD_fh = function () {
    return this.Jiedian.nodeName;
}

//------------↑↑↑↑↑【删除节点】↑↑↑↑↑------------


;
///<jscompress sourcefile="_NR.js" />

/**
 * 创建内容节点
 * @param {文本}} neiRong 内容
 * @returns 
 */
NW02_jd.prototype.cjNRjd = function (neiRong) {
    let _Erzi = document.createTextNode(neiRong);
    this.Jiedian.appendChild(_Erzi);// 将两个节点，变成父子(fuZi)关系
    return _Erzi;
}

/**
 * 删除本节点的内容
 * @param {真假} SCJD 真=将内容节点对象 删除。 假：只清空内容。
 */
NW02_jd.prototype.scNR = function (SCJD) {
    if (SCJD) {
        this.wgj.scNRjd(this.Jiedian)
    } else {//只清空内容
        //取内容节点
        let _NR = this.hqNRjd();
        if (_NR) {
            //设置内容值为''
            _NR.nodeValue = '';
        }
    }
}
/**
 * 
 * 修改内容
 * 如果没有文本节点,会自动创建；
 * 如果已经有文本节点，会根据 zuijia ，进行追加或替换。
 * 
 * 备注:zuijia=true表示追加；zuijia=false表示添加（默认值）
 * 
 * @参数 {对象} text 文本
 * @参数  {真假} zuijia 真=追加 ；假=覆盖（默认）
 */
NW02_jd.prototype.xgNR_html = function (neiRong, zuijia) {
    if (zuijia) {
        this.Jiedian.innerHTML += neiRong;
    } else { //如果没有文本节点
        this.Jiedian.innerHTML = neiRong;
    }
}


/**
 * 
 * 修改内容
 * 如果没有文本节点,会自动创建；
 * 如果已经有文本节点，会根据 zuijia ，进行追加或替换。
 * 
 * 备注:zuijia=true表示追加；zuijia=false表示添加（默认值）
 * 
 * @参数 {对象} text 文本
 * @参数  {真假} zuijia 真=追加 ；假=覆盖（默认）
 */
NW02_jd.prototype.xgNR = function (neiRong, zuijia) {
    let _NR = this.hqNRjd();
    if (_NR) {
        _NR.nodeValue = zuijia ? _NR.nodeValue + neiRong : neiRong;
    } else { //如果没有文本节点
        _NR = this.cjNRjd(neiRong);
    }
}


/**
 *  取得 内容节点
 * 
 * @返回 {对象}返回 文本节点。如果没有，返回null
 */
NW02_jd.prototype.hqNRjd = function () {
    return this.wgj.hqNRjd(this.Jiedian);
}
/**
 *  取得 内容
 * 
 * @返回 {对象}返回 文本节点。如果没有，返回null
 */
NW02_jd.prototype.hqNR = function () {
    return this.wgj.hqNRjd(this.Jiedian).nodeValue;
}

NW02_jd.prototype.hqNR_html = function () {
    return this.Jiedian.innerHTML;
}


/**
 * 取得所有 内容节点（包含它的所有下游 文本对象 ）文本对象 。
 * @返回 {真|假} pdGuolvHHF 是否过滤 换行符号(HHF); true=过滤；false=不过滤
 */
NW02_jd.prototype.hqNRjdM = function (pdGuolvHHF) {
    let _JG = []; //数组-存放 文本对象 的结果容器
    this.wgj.hqNRjdM(this.Jiedian, _JG, pdGuolvHHF)
    return _JG;
}



// 暂时不提供。不完善
// /**
//  * 取得 内容（包含它的所有下游 文本对象 ）文本。
//  * 所有节点的名称，自动转成内容模式
//  * @返回 {真|假} pdGuolvHHF 是否过滤 换行符号(HHF); true=过滤；false=不过滤
//  */
// NW02_jd.prototype.hqNRM = function (pdGuolvHHF) {
//     let _JG = []; //数组-存放 文本对象 的结果容器
//     this.wgj.hqNRjdM(this.Jiedian, _JG, pdGuolvHHF)
//     let nr = '';
//     let _NRjd;
//     let _Fjd = this.Jiedian.parentNode; //取节点父亲

//     for (let i = 0; i < _JG.length; i++) {
//         _NRjd = _JG[i];
//         _Fjd = _NRjd.parentNode; //取节点父亲
//         if (_Fjd == this.Jiedian) {// 当前节点的文本
//             nr += _NRjd.nodeValue;
//         } else {
//             nr += '<' + _Fjd.nodeName + '>' + _NRjd.nodeValue + '</' + _Fjd.nodeName + '>'
//         }
//     }
//     return nr;
// }
;
///<jscompress sourcefile="_SX.js" />
/**
 * 创建(cj)一个属性(SX)
 * @参数 {文本} ming 属性名
 * @参数 {文本} zhi 属性值
 * 
 * @返回 {对象} 节点的【属性对象】
 */
NW02_jd.prototype.cjSX = function (ming, zhi) {
    let _SX = document.createAttribute(ming); //创建一个新的属性
    if (zhi) { //设置属性值
        _SX.value = zhi;
    }
    this.Jiedian.setAttributeNode(_SX); //加入属性到节点里
    return _SX; //返回属性对象。
}

/**
 * 移除一个或多个属性
 * 多个属性时，请以 [逗号] 或 [分号] 隔开属性。
 * 示例：
 * "属性1,属性2,属性3...................属性N"    逗号隔开
 * "属性1;属性2;属性3...................属性N"    分号隔开
 * 
 * @参数 {文本} keys 属性名列表 或单个 属性名
 */
NW02_jd.prototype.scSX = function (sxLB) {
    if (sxLB && this.wgj.pdWenben(sxLB)) { //只对真值处理，并且，是字符串的属性
        //表示有多个属性要一起删除
        if (sxLB.indexOf(',') != -1 || sxLB.indexOf(';') != -1) {
            let cvs = sxLB.split(/[;, ]{1}/); //切割
            let _ming;
            for (let j = 0; j < cvs.length; j++) {
                _ming = this.wgj.scKong(cvs[j]); //对【切割1】出来的每一个节点,去两头空
                if (_ming) { //是真值时,才会进入下一步。
                    this.Jiedian.removeAttribute(_ming);
                }
            }
        } else {
            this.Jiedian.removeAttribute(sxLB);
        }
    }
}


/**
 * 修改属性（批量）
 * 
 * 接收的格式有：
 *   第1种：对象型。示例： {a:'值',b:'值1'}
 *   第2种：字符串型："id=abc;bc:aa,dd=123"
 * 
 * 备注：
 *  注意第2种，
 *      有两种写法，id=abc 和 bc:aa  。即，无论是=号还是：号，都可以被框架识别。
 *      另外，支持;号或,号分隔 属性
 * 
 * @参数 {object|string} SXlb 属性列表|属性名
 * @参数 {文本} zhi 属性值
 */
NW02_jd.prototype.xgSX = function (SXlb, zhi) {
    if (!SXlb) { //不用理会假值
        return;
    }
    //第二种方式 设置属性
    if (this.wgj.pdWenben(SXlb)) {
        //表示多个属性，一起修改
        if (SXlb.indexOf('=') != -1 || SXlb.indexOf(':') != -1) {
            //切割用户传入的参数
            //切割1：从"a=b;c=d,f:a"这种格式，分离出来 a=b，c=d......;
            //切割2：再从a=b 分析  a，b ...........
            let _QGs = SXlb.split(/[;,]{1}/); //切割1
            let cvs2; //用来暂存【切割2】
            for (let j = 0; j < _QGs.length; j++) {

                _QGs[j] = this.wgj.scKong(_QGs[j]); //对【切割1】出来的每一个节点,去两头空
                if (_QGs[j]) { //是真值时,才会进入【切割2】步骤。
                    cvs2 = _QGs[j].split(/[:=]{1}/); //【切割2】
                    //拆分键值对，必须得到两个节点。即,长度一定是2
                    if (cvs2.length == 2) {
                        this._ngj_xgSX(this.wgj.scKong(cvs2[0]), cvs2[1]); ////设置属性
                    }
                }
            }
        }
        //表示修改单个属性
        else {
            // console.log('-----------------------------------------' + SXlb + '=' + zhi)
            this._ngj_xgSX(SXlb, zhi);
        }
    }

    //第一种方式 设置属性
    if (this.wgj.pdD(SXlb)) {
        let tempKey;
        for (let key in SXlb) {
            tempKey = this.wgj.scKong(key);
            this._ngj_xgSX(tempKey, SXlb[tempKey]); ////设置属性
        }
        return; //处理完即结束。不用理会其他的方式
    }

}

/**
 * 获取 一个属性
 * @参数 {文本} ming 属性名
 * @返回 {对象} 节点的【属性对象】
 */
NW02_jd.prototype.hqSX = function (ming) {
    return this.Jiedian.getAttributeNode(ming);
}

NW02_jd.prototype.hqSXzhi = function (ming) {
    let _SX = this.wgj.pdWenben(ming) ? this.hqSX(ming) : ming;
    return _SX ? _SX.value : null;
}

/**
 * 
 * 获取 本属性及其下游节点的所有属性
 * 
 * @参数 {数组} SXJiedianS 缓存 有模板符号的 属性.如果为null，方法会自动创建一个数组。
 */
NW02_jd.prototype.hqMBsxM = function (SXJiedianS) {
    // nw.JK.hqJiedian_sxS(this.Jiedian, SXJiedianS)
    let _JG = SXJiedianS ? SXJiedianS : [];
    this.wgj.hqMBsxM(this.Jiedian, _JG);
    return _JG;
}


//========================================内工具========================================

//内工具：修改单个属性
NW02_jd.prototype._ngj_xgSX = function (ming, zhi) {
    if (null == zhi) {
        this.scSX(ming);
        return;
    }
    let _SX = this.hqSX(ming);
    if (_SX) {
        _SX.value = zhi;
    } else {
        this.cjSX(ming, zhi)
    }
}
;
///<jscompress sourcefile="NW02_ys.js" />
/**
 * DOM对象封装  样式
 */
function NW02_ys(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.gj = fq.gj;
    this.wgj = fq.wgj;
    this.Jiedian = fq.Jiedian;
    this.Yangshi = fq.Yangshi;

    this.YSBM = null;


    /**
    * 【工具】
    * 【只留数字】——所有非数据类的，都会被剔除。然后,转成float型数字，并返回出去。
    * @参数 {文本} yuan 源字符串。
    * @参数 {真假} pdInt  是否返回int类型的值；默认否（返回float); 为true时，返回int类型的结果。
    * @返回 {int|float} 数值
    */
    this._ngj_zlsz = this.wgj.zlShuzi


    this.qd0_YSbm();

}

//只留下字母和%
NW02_ys.prototype._ngj_zlzm = function (yuan) {
    let a = /^[a-z]$/i;
    if (yuan) {
        let _WenbenShuzuS = yuan.split('');//文本数组
        let _Rongqi = '';//容器
        for (let i = 0; i < _WenbenShuzuS.length; i++) {
            if (a.test(_WenbenShuzuS[i])) {
                _Rongqi += _WenbenShuzuS[i]
            }
        }
        return _Rongqi;
    }

};
///<jscompress sourcefile="_hqYScs.js" />
// ------------------------------------------【【获取样式参数】】
// =================内边距数据==============
//上
NW02_ys.prototype.hqNBJ_s = function () {
	return this._ngj_zlsz(this.Yangshi.paddingTop);
}
//下
NW02_ys.prototype.hqNBJ_x = function () {
	return this._ngj_zlsz(this.Yangshi.paddingBottom);
}
//左
NW02_ys.prototype.hqNBJ_z = function () {
	return this._ngj_zlsz(this.Yangshi.paddingLeft);
}
//右
NW02_ys.prototype.hqNBJ_y = function () {
	return this._ngj_zlsz(this.Yangshi.paddingRight);
}

// =================外边距数据==============
/**
 * 【外边距】
 */
NW02_ys.prototype.hqWBJ = function () {
	return this._ngj_zlsz(this.Yangshi.margin);
}
/**
 *【外边距】 上
 */
NW02_ys.prototype.hqWBJ_s = function () {
	return this._ngj_zlsz(this.Yangshi.marginTop);
}
/**
 * 【外边距】下
 */
NW02_ys.prototype.hqWBJ_x = function () {
	return this._ngj_zlsz(this.Yangshi.marginBottom);
}
/**
 * 【外边距】左
 */
NW02_ys.prototype.hqWBJ_z = function () {
	return this._ngj_zlsz(this.Yangshi.marginLeft);
}
/**
 * 【外边距】右
 */
NW02_ys.prototype.hqWBJ_y = function () {
	return this._ngj_zlsz(this.Yangshi.marginRight);
}

// =================边框数据==============
/**
 * 【边框信息】边粗
 */
NW02_ys.prototype.hqBK = function () {
	return this._ngj_zlsz(this.Yangshi['borderWidth']);
}
/**
 * 【边框信息】上 边粗
 */
NW02_ys.prototype.hqBK_s = function () {
	return this._ngj_zlsz(this.Yangshi['borderTopWidth']);
}
/**
 * 【边框信息】下 边粗
 */
NW02_ys.prototype.hqBK_x = function () {
	return this._ngj_zlsz(this.Yangshi['borderBottomWidth']);
}
/**
 * 【边框信息】左 边粗
 */
NW02_ys.prototype.hqBK_z = function () {
	return this._ngj_zlsz(this.Yangshi['borderLeftWidth']);
}
/**
 * 【边框信息】右 边粗
 */
NW02_ys.prototype.hqBK_y = function () {
	return this._ngj_zlsz(this.Yangshi['borderRightWidth']);
}

// =================盒子宽==============
/**
 * 1、【实时的宽】= 【宽】-【宽-y轴滚动条】;
 */
NW02_ys.prototype.hqK = function () {
	return this._ngj_zlsz(this.Yangshi['width']);
}
NW02_ys.prototype.hqK_dw = function () {
	return this._ngj_zlzm(this.Yangshi['width'])
}
/**
 * 2、【宽-边框内】=【宽】+【内边距-左】+【内边距-右】
 */
NW02_ys.prototype.hqK_bkn = function () {
	return this.Jiedian.clientWidth;
}
/**
 * 2、【宽-边框内】(兼容）
 */
NW02_ys.prototype.hqK_bkn2 = function () {
	return this.Jiedian.innerWidth || this.Jiedian.clientWidth;
}
/**
 * 3、【宽-边框外】=【宽_边框内】+【边框-左】+【边框-右】+【宽-y轴滚动条】
 */
NW02_ys.prototype.hqK_bkw = function () {
	return this.Jiedian.offsetWidth;
}
/**
*4、【宽-内容区】			=
*		if(【宽_边框内】>=【内容B占有宽】) ){
*			return 【宽_边框内】
*		}else{
*			return 【内容B占有宽】
*		}
*备注：let 【内容B占有宽】= B的【宽_边框外】+B的【外边距-左】+【内边距-左】
*/
NW02_ys.prototype.hqK_nr = function () {
	return this.Jiedian.scrollWidth;
}
/**
 * 5、【宽-隐藏的内容】
 */
NW02_ys.prototype.hqK_ycNR = function () {
	return this.Jiedian.scrollLeft;
}
/**
 * 6、【宽-y轴滚动条】= 【宽_边框外】-【宽_边框内】-【边框-左】-【边框-右】
 */
NW02_ys.prototype.hqK_yGDT = function () {
	return this.hqK_bkw() - this.hqK_bkn() - this.hqBK_z() - this.hqBK_y();
}
/**
 * 7、【宽】-用户原始设置的= 【宽】+【宽-y轴滚动条】
 */
NW02_ys.prototype.hqK2 = function () {
	return this.hqK() + this.hqK_yGDT();
}


// =================盒子高==============
/**
 * 1、【实时的高】= 【高】-【高-x轴滚动条】;
 */
NW02_ys.prototype.hqG = function () {
	return this._ngj_zlsz(this.Yangshi['height']);
}

//单位
NW02_ys.prototype.hqG_dw = function () {
	return this._ngj_zlzm(this.Yangshi['height'])
}

/**
 * 2、【高-边框内】= 【高】+ 【内边距-上】+ 【内边距-下】
 */
NW02_ys.prototype.hqG_bkn = function () {
	return this.Jiedian.clientHeight;
}
/**
 * 2、【高-边框内】(兼容）= 【高】+ 【内边距-上】+ 【内边距-下】
 */
NW02_ys.prototype.hqG_bkn2 = function () {
	return this.Jiedian.innerHeight || this.Jiedian.clientHeight;
}
/**
 * 3、【高-边框外】= 【高_边框内】+【边框-上】+ 【边框-下】+ 【高-x轴滚动条】
 */
NW02_ys.prototype.hqG_bkw = function () {
	return this.Jiedian.offsetHeight;
}
/**
 * 4、【高—内容】 =
 * 		if(【高_边框内】>=【内容B占有高】) ){
 * 			return 【高_边框内】
 * 		}else{
 * 			return 【内容B占有高】//同时，A也会出现滚动条
 * 		}
 *备注：let 【内容B占有高】= B的【高_边框外】+B的【外边距-上】+B的【外边距-下】+【内边距-上】+【内边距-下】
 */
NW02_ys.prototype.hqG_nr = function () {
	return this.Jiedian.scrollHeight;
}
/**
 * 5、【高-隐藏的内容】
 */
NW02_ys.prototype.hqG_ycNR = function () {
	return this.Jiedian.scrollTop;
}

/**
 * 6、【高-x轴滚动条】= 【高_边框外】-【高_边框内】-【边框-上】-【边框-下】
 */
NW02_ys.prototype.hqG_xGDT = function () {
	return this.hqG_bkw() - this.hqG_bkn() - this.hqBK_s() - this.hqBK_x();
}
/**
 * 7、【高】-用户原始设置的
 */
NW02_ys.prototype.hqG2 = function () {
	return this.hqG() + this.hqG_xGDT();
}


/*
假定 A包含着B（比如，是一个div，用来放内容）。针对A的情况：
---------------------------------------------------
1、【实时的宽】        		= 【宽】-【宽-y轴滚动条】;
2、【宽_边框内】   			= 【宽】+ 【内边距-左】+ 【内边距-右】
3、【宽_边框外】   			= 【宽_边框内】+ 【边框-左】+ 【边框-右】+ 【宽-y轴滚动条】

4、【宽-内容区】			=
if(【宽_边框内】>=【B占有宽】) ){
	return 【宽_边框内】
}else{
	return 【B占有宽】
}
备注：let 【B占有宽】= B的【宽_边框外】+B的【外边距-左】+【内边距-左】

5、【宽-隐藏的内容】
6、【宽-y轴滚动条】			= 【宽_边框外】-【宽_边框内】-【边框-左】-【边框-右】
7、【宽】-用户初始设置的值	 = 【宽】+【宽-y轴滚动条】
---------------------------------------------------
---------------------------------------------------
1、【实时的高】        		= 【高】-【高-x轴滚动条】;
2、【高_边框内】  		 	= 【高】+ 【内边距-上】+ 【内边距-下】
3、【高-边框外】   			= 【高_边框内】+【边框-上】+ 【边框-下】+ 【高-x轴滚动条】

4、【高-内容区】=
if(【高_边框内】>=【B占有高】) ){
	return 【高_边框内】
}else{
	return 【B占有高】//同时，A也会出现滚动条
}
备注：let 【B占有高】= B的【高_边框外】+B的【外边距-上】+B的【外边距-下】+【内边距-上】+【内边距-下】

5、【高-隐藏的内容】
6、【高-x轴滚动条】			= 【高_边框外】-【高_边框内】-【边框-上】-【边框-下】
7、【高】-用户初始设置的值	 = 【高】+【高-x轴滚动条】

*/;
///<jscompress sourcefile="_NYS.js" />

/**
 * 设置 Style样式
 * 
 * 接收的格式有：
 *   第1种：对象型。示例： {a:'值',b:'值1'}
 *   第2种：字符串型："id=abc;bc:aa,dd=123"
 * 
 * 备注：
 *  注意第2种，
 *      有两种写法，id=abc 和 bc:aa  。即，无论是=号还是：号，都可以被框架识别。
 *      另外，支持;号或,号分隔 属性
 * 
 * @参数 {object|string} values 属性列表
 * @参数 {true|false} cover 开关；是否覆盖全部（true=覆盖全部；false=表示追加\更新）
 */
NW02_ys.prototype.xgNYS = function (Yangshi, pdFugai) {
    if (pdFugai) { //如果覆盖全部。
        this.Jiedian.style = null;
    }
    if (!Yangshi) {
        this.Jiedian.style = null;
        return;
    }

    //第二种方式 设置Style样式
    if (this.wgj.pdWenben(Yangshi)) {
        let _Yangshi1 = Yangshi.split(/[;,]{1}/); //切割1
        let _Yangshi2; //用来暂存【切割2】
        for (let j = 0; j < _Yangshi1.length; j++) {
            _Yangshi1[j] = this.wgj.scKong(_Yangshi1[j]); //对【切割1】出来的每一个节点,去两头空
            if (_Yangshi1[j]) { //是真值时,才会进入【切割2】步骤。
                _Yangshi2 = _Yangshi1[j].split(/[:=]{1}/); //【切割2】
                //拆分键值对，必须得到两个节点。即,长度一定是2
                if (_Yangshi2.length == 2) {
                    //可能_name是别名，不能被系统识别，所以，先通过别名转换方法，再执行样式值操作。。
                    this.Jiedian.style[this.hqYSbm(this.wgj.gshSXM(_Yangshi2[0]))] = _Yangshi2[1]; //更新或添加 样式。
                }
            }
        }
    }
    // let _mingzi;//样式名-有可能是别名
    //第一种方式 设置Style样式
    if (this.wgj.pdD(Yangshi)) {
        for (let _mingzi in Yangshi) { //_mingzi ：样式游标 的意思。
            _mingzi = this.wgj.gshSXM(_mingzi);
            //可能_name是别名，不能被系统识别，所以，转成系统名。
            this.Jiedian.style[this.hqYSbm(_mingzi)] = Yangshi[_mingzi]; //更新或添加 样式。
        }
        return; //处理完即结束。不用理会其他的方式
    }
}

/**
 * 删除 style里面，指定的属性项 比如 styleValue="height,text-align"
 * @参数 {文本} styleValue style里面的选项
 */
NW02_ys.prototype.scNYS = function (yangShiMing) {
    if (!yangShiMing) {
        return;
    }
    //切割用户传入的参数
    let _YHYangshi_SZ = yangShiMing.split(/[,; ]{1}/);//从这一步开始，yangShiMing变量可以当临时变量用。
    //对每一个节点，进行除空.并检测是否有style值，如果有，设置为null
    for (let j = 0; j < _YHYangshi_SZ.length; j++) {
        //去两头空，进行别名检测，如果是别名，取真名返回。
        yangShiMing = this.hqYSbm(this.wgj.gshSXM(_YHYangshi_SZ[j]))
        if (yangShiMing && this.Jiedian.style[yangShiMing]) { //是否有style值
            this.Jiedian.style[yangShiMing] = null; //如果有，设置为null
        }
    }
}

/**
 * 检查此节点是否包含样式
 * 
 * @参数 {文本} ming 样式名
 * @返回 true=包含样式;false=不包含样式
 */
NW02_ys.prototype.hqNYS = function (ming) {
    return this.Jiedian.style[this.hqYSbm(ming)];
}

//显示，通过内样式
NW02_ys.prototype.xgNYS_xs = function () {
    this.Jiedian.style['display'] = null;
}

//隐藏，通过内样式
NW02_ys.prototype.pdYC = function () {
    return this.Jiedian.style['display'] == 'none';
}
//隐藏，通过内样式
NW02_ys.prototype.xgNYS_yc = function () {
    this.Jiedian.style['display'] = 'none';
}

//显示|隐藏，通过内样式
NW02_ys.prototype.xgNYS_xsHyc = function () {
    if (this.Jiedian.style['display'] == 'none') {
        this.xgNYS_xs();
    } else {
        this.xgNYS_yc();
    }
}

NW02_ys.prototype.xs = function (dm) {
    if (dm == undefined) {
        this.xgNYS_xsHyc();
    } else if (dm) {
        this.xgNYS_xs();
    } else {
        this.xgNYS_yc();
    }
}
;
///<jscompress sourcefile="_WYS.js" />
/**
 * 修改节点外样式
 * @参数 {文本} waiYangshi 外样式(class)
 * @参数 {true|false} pdFuGai 开关；是否覆盖全部（true=覆盖全部；false=表示追加\更新）
 */
NW02_ys.prototype.xgWYS = function (waiYangshi, pdFuGai) {
    if (this.Jiedian.className) { //如果节点已经存在外样式属性
        if (pdFuGai) {
            this.Jiedian.className = waiYangshi;
        } else {
            let _jg = '';
            let SZ2 = waiYangshi.split(/[,; ]{1}/);  // ['my ','     my2','']
            //对每一个节点，进行除空
            for (let j = 0; j < SZ2.length; j++) {
                if (SZ2[j]) {
                    SZ2[j] = this.wgj.gshSXM(SZ2[j]); // ['my','my2']
                }
            }
            let _yuan = this.Jiedian.className;
            for (let j = 0; j < SZ2.length; j++) {
                if (!SZ2[j] || _yuan.indexOf(SZ2[j]) != -1) {//表示已经有。不用再添加。
                    continue;
                }
                _jg += ' ' + SZ2[j];
            }
            if (_jg) {
                this.Jiedian.className = this.Jiedian.className + _jg;
            }

        }
    } else { //到这一步，表示没有样式。可以直接附值。
        this.Jiedian.className = waiYangshi.replace(/[,;]/g, " ");
    }
}

/**
 * 删除指定 class样式；
 * 比如，删除 'my my2' 两个样式（注意，需要空开两个样式）
 * 
 * @参数 {文本} yh_wys class样式
 */
NW02_ys.prototype.scWYS = function (yh_wys) {
    let _wys = this.Jiedian.className;
    if (!yh_wys) {//如果不指定。表示删除所有的外样式。
        if (_wys) { //如果节点已经存在外样式属性
            this.Jiedian.className = null
        }
        return;
    }

    //确保节点有样式值，传入的参数classValue也是真值。
    if (_wys) {

        let _YuanYangshi = _wys.split(' '); //提取节点本身的样式，进行分割。

        //切割用户传入的参数 三种格式： 'my my2'  'my ,my2'   'my; my2'  
        let _YonghuYangshi = yh_wys.split(/[,; ]{1}/);              // ['my ','     my2']
        //对每一个节点，进行除空
        for (let j = 0; j < _YonghuYangshi.length; j++) {
            _YonghuYangshi[j] = this.wgj.gshSXM(_YonghuYangshi[j]); // ['my','my2']
        }

        //开始 逐个检测 源头 样式。如果与用户传入的样式相同，则表示要删除的。
        //通过检测后，源头样式中，非null值的,都是需要保留的样式。（null值的,都是要删除的）
        for (let i = 0; i < _YuanYangshi.length; i++) {//检测 未删除前，原有的样式。
            if (_YuanYangshi[i] == ' ') {//空的，跳过。
                _YuanYangshi[i] = null;
                continue;
            }
            _YuanYangshi[i] = this.wgj.gshSXM(_YuanYangshi[i]); //去除空（如果有）
            //拿到一个源头样式sources[i]后，看看是不是用户要求删除的样式
            for (let j = 0; j < _YonghuYangshi.length; j++) {//要删除的样式： ['my','my2']
                if (_YuanYangshi[i] == _YonghuYangshi[j]) { //如果是用户要求删除的样式，
                    _YuanYangshi[i] = null; //将源头的样式_YuanYangshi[i]，设置值为null
                    break; //跳出当前循环。
                }
            }
        }

        let xgYangshi = '';//需要修改的样式
        //重新连接回样式。跳过null值的
        for (let i = 0; i < _YuanYangshi.length; i++) {
            if (_YuanYangshi[i]) {//真值的，都是要保留的样式（其null值的,都是用户要求删除的样式）
                xgYangshi += " " + _YuanYangshi[i];
            }
        }
        this.xgWYS(xgYangshi, true);
    }
}

/**
 * 检查此节点是否包含样式
 * 
 * @参数 {文本} ming 样式名
 * @返回 true=包含样式;false=不包含样式
 */
NW02_ys.prototype.pdWYS = function (ming) {
    if (ming) {
        ming = this.wgj.gshSXM(ming);
        let _Yangshi = this.Jiedian.className.split(' '); //提取节点本身的样式，进行分割。
        for (let i = 0; i < _Yangshi.length; i++) {
            if (ming == this.wgj.gshSXM(_Yangshi[i])) {
                return true;
            }
        }
    }
    return false;
};
///<jscompress sourcefile="_xy.js" />
// 空间坐标管理

/**
 * 设置本节点的 [x0,y0]
 * @参数 {string} x0
 * @参数 {string} y0
 */
NW02_ys.prototype.x0y0 = function (x0, y0, dw) {
    this._ngj_wz();
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.left = x0 + dw;
    this.Jiedian.style.top = y0 + dw;
}
//放置左上角
NW02_ys.prototype.xy_zsj = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_zsj(x, y, dw)
}
//放置左上角
NW02_ys.prototype.xy_zsj2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_zsj(x, y, dw)
}
//放置左上角
NW02_ys.prototype._ngj_xy_zsj = function (x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.right = null;
    this.Jiedian.style.bottom = null;
    this.Jiedian.style.left = x + dw;
    this.Jiedian.style.top = y + dw;
}

//上中
NW02_ys.prototype.xy_sz = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_sz(nw.cj(this.Jiedian.parentNode), x, y, dw)
}
//上中
NW02_ys.prototype.xy_sz2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_sz(nw.st, x, y, dw)
}
NW02_ys.prototype._ngj_xy_sz = function (fq, x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.right = null;
    this.Jiedian.style.bottom = null;

    let k = fq.ys.hqK() / 2 - this.hqK_bkw() / 2 - this.hqWBJ_z() + x;
    this.Jiedian.style.left = k + dw;
    this.Jiedian.style.top = y + dw;
}


// 放置右上角
NW02_ys.prototype.xy_ysj = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_ysj(x, y, dw)
}
// 放置右上角 固定定位
NW02_ys.prototype.xy_ysj2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_ysj(x, y, dw)
}
// 放置右上角
NW02_ys.prototype._ngj_xy_ysj = function (x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.left = null;
    this.Jiedian.style.bottom = null;
    this.Jiedian.style.right = x + dw;
    this.Jiedian.style.top = y + dw;
}
//左中
NW02_ys.prototype.xy_zz = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_zz(nw.cj(this.Jiedian.parentNode), x, y, dw)
}
//左中2 固定定位
NW02_ys.prototype.xy_zz2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_zz(nw.st, x, y, dw)
}

NW02_ys.prototype._ngj_xy_zz = function (fq, x, y, dw) {
    this.Jiedian.style.right = null;
    this.Jiedian.style.bottom = null;
    if (!dw) {
        dw = 'px'
    }
    let g = fq.ys.hqG() / 2 - this.hqG_bkw() / 2 - this.hqWBJ_s() + y;
    this.Jiedian.style.left = x + dw;
    this.Jiedian.style.top = g + dw;
}


//右中
NW02_ys.prototype.xy_yz = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_yz(nw.cj(this.Jiedian.parentNode), x, y, dw)
}
//右中2 固定定位
NW02_ys.prototype.xy_yz2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_yz(nw.st, x, y, dw)
}
NW02_ys.prototype._ngj_xy_yz = function (fq, x, y, dw) {
    this.Jiedian.style.left = null;
    this.Jiedian.style.bottom = null;
    if (!dw) {
        dw = 'px'
    }
    let g = fq.ys.hqG() / 2 - this.hqG_bkw() / 2 - this.hqWBJ_s() + y;
    this.Jiedian.style.right = x + dw;
    this.Jiedian.style.top = g + dw;
}




//放置左下角
NW02_ys.prototype.xy_zxj = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_zxj(x, y, dw)
}
//放置左下角 固定定位
NW02_ys.prototype.xy_zxj2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_zxj(x, y, dw)
}

//放置左下角
NW02_ys.prototype._ngj_xy_zxj = function (x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.right = null;
    this.Jiedian.style.top = null;
    this.Jiedian.style.left = x + dw;
    this.Jiedian.style.bottom = y + dw;
}

//下中
NW02_ys.prototype.xy_xz = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_xz(nw.cj(this.Jiedian.parentNode), x, y, dw)
}
//下中 固定定位
NW02_ys.prototype.xy_xz2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_xz(nw.st, x, y, dw)
}

NW02_ys.prototype._ngj_xy_xz = function (fq, x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.right = null;
    this.Jiedian.style.top = null;
    let k = fq.ys.hqK() / 2 - this.hqK_bkw() / 2 - this.hqWBJ_z() + x;
    this.Jiedian.style.left = k + dw;
    this.Jiedian.style.bottom = y + dw;
}



// 放置右下角
NW02_ys.prototype.xy_yxj = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_yxj(x, y, dw);
}
// 放置右下角 固定定位
NW02_ys.prototype.xy_yxj2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_yxj(x, y, dw);
}

// 放置右下角
NW02_ys.prototype._ngj_xy_yxj = function (x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.top = null;
    this.Jiedian.style.left = null;
    this.Jiedian.style.right = x + dw;
    this.Jiedian.style.bottom = y + dw;
}
//---------------------

//正中间
NW02_ys.prototype.xy_zzj = function (x, y, dw) {
    this._ngj_wz();
    this._ngj_xy_zzj(nw.cj(this.Jiedian.parentNode), x, y, dw)
}

//正中间 固定定位
NW02_ys.prototype.xy_zzj2 = function (x, y, dw) {
    this._ngj_wz2();
    this._ngj_xy_zzj(nw.st, x, y, dw)
}

// 放置正中间
NW02_ys.prototype._ngj_xy_zzj = function (fq, x, y, dw) {
    if (!dw) {
        dw = 'px'
    }
    this.Jiedian.style.right = null;
    this.Jiedian.style.bottom = null;
    this.Jiedian.style.top = fq.ys.hqG() / 2 - this.hqG_bkw() / 2 - this.hqWBJ_s() + y + dw;
    this.Jiedian.style.left = fq.ys.hqK() / 2 - this.hqK_bkw() / 2 - this.hqWBJ_z() + x + dw;
}



NW02_ys.prototype._ngj_wz = function () {
    if (!this.hqNYS('position')) {
        this.xgNYS({ wz: 'absolute' })
    }
}
NW02_ys.prototype._ngj_wz2 = function (gddw) {
    if (this.hqNYS('position') != 'fixed') {
        this.xgNYS({ wz: 'fixed' })
    }
}


/**
 * 【x0】
 * 
 * @param {文本} zhi  坐标值 1px
 * @param {真假} qlX1  是否清理 x1
 * @returns x0值
 */
NW02_ys.prototype.x0 = function (zhi, qlX1) {
    if (zhi) {
        if (qlX1) {
            this.Jiedian.style.right = null;
        }
        this.Jiedian.style.left = zhi;
        return this;
    }
    // return this.Jiedian.offsetLeft - this.hqWBJ_z();
    return this._ngj_zlsz(this.Jiedian.style.left);
}

/**
 * 【x1】
 * 
 * @param {文本} zhi  坐标值 1px
 * @param {真假} qlX0  是否清理 X0
 * @returns x1值
 */
NW02_ys.prototype.x1 = function (zhi, qlX0) {
    if (zhi) {
        if (qlX0) {
            this.Jiedian.style.left = null;
        }
        this.Jiedian.style.right = zhi;
        return this;
    }
    return this._ngj_zlsz(this.Jiedian.style.right);
}

/**
 * 【y0】
 * 
 * @param {文本} zhi  坐标值 1px
 * @param {真假} qlY1  是否清理 Y1
 * @returns y0值
 */
NW02_ys.prototype.y0 = function (zhi, qlY1) {
    if (zhi) {
        if (qlY1) {
            this.Jiedian.style.bottom = null;
        }
        this.Jiedian.style.top = zhi;
        return this;
    }
    // return this.Jiedian.offsetTop - this.hqWBJ_s();
    return this._ngj_zlsz(this.Jiedian.style.top)
}

/**
 * 【y1】
 * 
 * @param {文本} zhi  坐标值 1px
 * @param {真假} qlY0  是否清理 Y0
 * @returns y1值
 */
NW02_ys.prototype.y1 = function (zhi, qlY0) {
    if (zhi) {
        if (qlY0) {
            this.Jiedian.style.top = null;
        }
        this.Jiedian.style.bottom = zhi;
        return this;
    }
    return this._ngj_zlsz(this.Jiedian.style.bottom);
}

//--------------------------------------------------------------------
/**
 * 【坐标x】 包含【外边距】
 * @param {真假} jqwbj  是否减去本节点的外边距-左
 * @returns x0坐标值
 */
NW02_ys.prototype.zb_x = function (jqwbj) {
    //  this.Jiedian.offsetLeft;
    return jqwbj ? this.Jiedian.offsetLeft - this.hqWBJ_z() : this.Jiedian.offsetLeft;
}


/**
 * 取得x坐标【相对-html节点】。
 * 
 * @param {真假} jqwbj  是否减去本节点的外边距-左
 * @返回 x坐标_相对于html
 */
NW02_ys.prototype.zb_x_html = function (jqwbj) {
    let _zb = this.zb_x();
    let _FQ = this.Jiedian.offsetParent; // 父节点
    while (_FQ) {
        _zb += _FQ.offsetLeft;
        _FQ = _FQ.offsetParent;
    }
    return jqwbj ? _zb - this.hqWBJ_z() : _zb;
}

/**
 * 【坐标y】 包含【外边距】
 * @param {真假} jqwbj  是否减去本节点的外边距-上
 * @返回 Top坐标点
 */
NW02_ys.prototype.zb_y = function (jqwbj) {
    //  this.Jiedian.offsetTop;
    return jqwbj ? this.Jiedian.offsetTop - this.hqWBJ_s() : this.Jiedian.offsetTop;
}

/**
 * 取得y坐标【相对-html节点】。
 * @param {真假} jqwbj   是否减去本节点的外边距-上
 * @返回 y坐标_相对于html
 */
NW02_ys.prototype.zb_y_html = function (jqwbj) {
    let _zb = this.zb_y();
    let _FQ = this.Jiedian.offsetParent; // 父节点
    while (_FQ) {
        _zb += _FQ.offsetTop;
        _FQ = _FQ.offsetParent;
    }
    return jqwbj ? _zb - this.hqWBJ_s() : _zb;
}


// 盒子【左上角】的【坐标x】，到其盒子【右上角】的 【点】(不包含【外边距-右】)
NW02_ys.prototype.zb_xDaoYS = function () {
    return this.zb_x() + this.hqK_bkw();
}

// 盒子【左上角】的【坐标y】，到其盒子【左下角】的 【点】(不包含【外边距-右】)
NW02_ys.prototype.zb_yDaoZX = function () {
    return this.zb_y() + this.hqG_bkw();
}

/**
 * xy坐标——右连接其他节点
 * 【本节点-右上角，不要边框_右的宽度 】
 * 与
 * 【pjdx节点-左上角，不要外边距_左】
 * 连接一起（重叠）
 * 
 * @param {nw对象} pjdx 节点id或节点对象或nw对象
 * @param {真假} blXBK  是否保留本节点的【边框-右】A的空间； 是=pjdx的左边框，紧贴着A线； 否=pjdx的左边框线，覆盖A线。
 * @param {文本} dw 默认为px
 * @returns  pjdx.ys
 */
NW02_ys.prototype.xy_ylj = function (pjdx, blXBK, dw) {

    //本盒子【右上角】
    let _pjdx_x;
    let _pjdx_y;
    if (!dw) {
        dw = 'px'
    }
    //如果pjdx是本节点的儿子
    if (this.Jiedian == pjdx.Jiedian.parentNode) {
        //采用 本节点-右上角配置。
        _pjdx_y = 0
            - pjdx.ys.hqWBJ_s()//不要【_pjdx  上则-外边距】
            - this.hqBK_s(); //让本节点的【上则线】与【_pjdx  _x上则线】起点一样。
        _pjdx_x = 0
            - pjdx.ys.hqWBJ_y()//不要【_pjdx  下则-外边距】
            - pjdx.ys.hqK_bkw()//【_pjdx  顶部线】在本节点【底部线】之下
            ;
        if (blXBK) {//如果需要保留 本节点的-【边框-下】的空间
            _pjdx_x = _pjdx_x - this.hqBK_y();
        }
        pjdx.ys.xy_ysj(_pjdx_x + dw, _pjdx_y + dw);
        return pjdx.ys;
    }
    _pjdx_x = this.zb_xDaoYS() - this.hqBK_y() - pjdx.ys.hqWBJ_z();
    _pjdx_y = this.zb_y() - pjdx.ys.hqWBJ_s();
    pjdx.ys.x0y0(_pjdx_x, _pjdx_y, dw);
    return pjdx.ys;
}

//下连接。将目标的左上角坐标点，与本节点的左下角坐标点，重叠一起。
/**
 * 
 * @param {nw对象} pjdx 被接到 本节点的 左下角的 盒子
 * @param {真假} blXBK  是否保留本节点的【边框-下】A的空间； 是=pjdx的上边框，紧贴着A线； 否=pjdx的上边框线，覆盖A线。
 * @param {文本} dw  单位。默认px
 * @returns  pjdx.ys
 */
NW02_ys.prototype.xy_xlj = function (pjdx, blXBK, dw) {
    let _pjdx_x;
    let _pjdx_y;
    if (!dw) {
        dw = 'px'
    }
    //如果pjdx是本节点的儿子
    if (this.Jiedian == pjdx.Jiedian.parentNode) {
        //采用 本节点-左下角配置。
        _pjdx_x = 0
            - pjdx.ys.hqWBJ_z()//不要【_pjdx  左则-外边距】
            - this.hqBK_z(); //让本节点的【左则线】与【_pjdx  _x左则线】起点一样。
        _pjdx_y = 0
            - pjdx.ys.hqWBJ_x()//不要【_pjdx  下则-外边距】
            - pjdx.ys.hqG_bkw()//【_pjdx  顶部线】在本节点【底部线】之下
            // - this.hqBK_x()    //【底部线】重合
            ;
        if (blXBK) {//如果需要保留 本节点的-【边框-下】的空间
            _pjdx_y = _pjdx_y - this.hqBK_x();
        }

        pjdx.ys.xy_zxj(_pjdx_x + dw, _pjdx_y + dw);
        return pjdx.ys;
    }
    //本盒子【右上角】
    // x  边框一样。不包括 外边距-左。）
    _pjdx_x = this.zb_x() - pjdx.ys.hqWBJ_z();
    _pjdx_y = this.zb_yDaoZX() - pjdx.ys.hqWBJ_s();
    if (!blXBK) {//如果不需要保留 本节点的-【边框-下】的空间
        _pjdx_y = _pjdx_y - this.hqBK_x();
    }
    pjdx.ys.x0y0(_pjdx_x, _pjdx_y, dw);
    return pjdx.ys;
};
///<jscompress sourcefile="_YSBM.js" />
/**
 * 删除 style里面，指定的属性项 比如 styleValue="height,text-align"
 * @参数 {文本} styleValue style里面的选项
 */
NW02_ys.prototype.hqYSbm = function (ming) {
    if (!ming) {
        return null;
    }
    let _zhi = this.YSBM[ming];
    return _zhi ? _zhi : ming;
}


NW02_ys.prototype.qd0_YSbm = function () {
    this.YSBM = {
        // 功能开关的
        wz: 'position',         //位置 开关
        xs: 'display',          //显示 开关
        
        // 描述高的 y轴

        g: 'height',            //高
        g_zx: 'min-height',     //最小高
        g_zd: 'max-height',     //最大高
        g_hg: 'line-height',    //行高

        // 描述宽 x轴
        k: 'width',//宽
        k_zx: 'min-width',      //最小宽
        k_zd: 'max-width',      //最大宽

        // 描述 z轴的
        zkj: 'z-index',         //z空间层次

        //描述空间的 （x,y,z)


        // 描述空间方向的
        z: 'left',             //左
        x0: 'left',             //左
        X0: 'left',             //左
        y: 'right',            //右
        x1: 'right',            //右
        X1: 'right',            //右

        s: 'top',              //上
        y0: 'top',              //上
        y0: 'top',              //上
        x: 'bottom',           //下
        y1: 'bottom',           //下
        Y1: 'bottom',           //下

        //滚动 描述空间溢出时，要不要滚动
        gd: 'overflow',         //超出 x与y
        gd_x: 'overflow-x',     //x轴方向，超出空间
        gd_y: 'overflow-y',     //y轴方向，超出空间

        //描述边框的
        bk: 'border',           //边框
        bk_s: 'border-top',     //边框-上
        bk_x: 'border-bottom',  //边框-下
        bk_z: 'border-left',    //边框-左
        bk_y: 'border-right',   //边框-右

        //描述外边距的
        wbj: 'margin',          //外边距
        wbj_s: 'margin-top',    //外边距-上
        wbj_x: 'margin-bottom', //外边距-下
        wbj_z: 'margin-left',   //外边距-左
        wbj_y: 'margin-right',  //外边距-右

        //描述内边距的
        nbj: 'padding',         //内边距
        nbj_s: 'padding-top',   //内边距-上
        nbj_x: 'padding-bottom',//内边距-下
        nbj_z: 'padding-left',  //内边距-左
        nbj_y: 'padding-right', //内边距-右

        //描述空间背景的
        bj_ys: 'background-color',  //背景颜色
        bj_t: 'background-image',   //背景图

        //描述字体的
        zt_ys: 'color',         //字体颜色
        zt_dx: 'font-size',     //字体大小
        zt_cx: 'font-weight',   //字体粗细

        //描述内容的
        nr_wz_y: 'text-align'   //内容位置
    }
}
;
///<jscompress sourcefile="NW02_jt_cm.js" />
//用于记录触摸参数。
function NW02_jt_cmCS() {
    this.jl_x = 0;      //本次移动了多少距离=本次坐标点-上次坐标点
    this.jl_y = 0;      //本次移动了多少距离=本次坐标点-上次坐标点

    this.sycZB_y = 0;   //记录y轴的 上一次移动。停止接触屏幕时，自动归0
    this.sycZB_x = 0;   //记录x轴的 上一次移动。停止接触屏幕时，自动归0

    this.fx0 = '';      //最开始的方向-移动方向。在末离开屏幕之前，都锁定 最开始的方向。
    this.fx = '';       //移动方向
}

//刚刚开始触摸，必须调用本方法
NW02_jt_cmCS.prototype.ks = function (e) {
    let _DX = e.touches[0];
    this.sycZB_x = _DX.pageX;
    this.sycZB_y = _DX.pageY;
}

//移动时，必须调用本方法。只要移动状态，就不断更新参数。主要是 更新方向。
NW02_jt_cmCS.prototype.yd = function (e) {
    let _DX = e.touches[0];
    this.jl_y = _DX.pageY - this.sycZB_y;
    this.jl_x = _DX.pageX - this.sycZB_x;

    if (Math.abs(this.jl_x) > Math.abs(this.jl_y) && this.jl_x > 0) {
        if (!this.fx0) {
            this.fx0 = 'y'
        }
        this.fx = 'y'
    }
    else if (Math.abs(this.jl_x) > Math.abs(this.jl_y) && this.jl_x < 0) {
        if (!this.fx0) {
            this.fx0 = 'z'
        }
        this.fx = 'z'
    }
    else if (Math.abs(this.jl_y) > Math.abs(this.jl_x) && this.jl_y > 0) {
        if (!this.fx0) {
            this.fx0 = 'x'
        }
        this.fx = 'x';
    }
    else if (Math.abs(this.jl_y) > Math.abs(this.jl_x) && this.jl_y < 0) {
        if (!this.fx0) {
            this.fx0 = 's'
        }
        this.fx = 's';
    }
    this.sycZB_y = _DX.pageY;
    this.sycZB_x = _DX.pageX;
}

//触摸事件结束后，必须调用本方法
NW02_jt_cmCS.prototype.js = function () {//结束
    this.sycZB_x = 0;   //记录y轴的 上一次移动。停止接触屏幕时，自动归0
    this.sycZB_y = 0;   //记录x轴的 上一次移动。停止接触屏幕时，自动归0
    this.jl_y = 0;
    this.jl_x = 0;
    this.fx = '';
    this.fx0 = ''
};
///<jscompress sourcefile="NW02_jt.js" />
/**
 * DOM对象封装  行为
 */
function NW02_jt(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.gj = fq.gj;
    this.wgj = fq.wgj;
    this.jd = fq.jd;
    this.ys = fq.ys;
    this.Jiedian = fq.Jiedian;
};
///<jscompress sourcefile="_0_jt.js" />
//------------↓↓↓↓↓【事件——监听】↓↓↓↓↓------------
/**
 * 添加监听
 * @参数 {事件key} daihao 事件代号
 * @参数 {函数} ff 事件触发时，自动调用的函数
 * @参数 {布尔值} useCapture 可选。布尔值，指定事件是否 在捕获或冒泡阶段执行。
 *  false- 默认。事件句柄在冒泡阶段执行.
 *  true - 事件句柄在捕获阶段执行
 */
NW02_jt.prototype.tj = function (daihao, ff, useCapture) {
	this.Jiedian.addEventListener(daihao, ff, useCapture)
}
//------------↑↑↑↑↑【事件——监听】↑↑↑↑↑------------


/**
 * 添加一个点击事件 addEventListener 方式
 * @参数 {函数} ff 函数
 * @参数 {布尔值} useCapture 可选。布尔值，指定事件是否 在捕获或冒泡阶段执行。
 *  false- 默认。事件句柄在冒泡阶段执行.
 *  true - 事件句柄在捕获阶段执行
 */
NW02_jt.prototype.tj_sb_dj = function (ff, useCapture) {
	this.tj('click', ff, useCapture);
}
/**
 * 添加一个【鼠标移进节点范围的事件】事件 addEventListener 方式
 * @参数 {函数} ff 函数
 * @参数 {布尔值} useCapture 可选。布尔值，指定事件是否 在捕获或冒泡阶段执行。
 *  false- 默认。事件句柄在冒泡阶段执行.
 *  true - 事件句柄在捕获阶段执行
 */
NW02_jt.prototype.tj_sb_jr = function (ff, useCapture) {
	this.tj('mouseover', ff, useCapture);
}

/**
 * 添加一个【鼠标移出节点范围的事件】 addEventListener 方式
 * @参数 {函数} ff 函数
 * @参数 {布尔值} useCapture 可选。布尔值，指定事件是否 在捕获或冒泡阶段执行。
 *  false- 默认。事件句柄在冒泡阶段执行.
 *  true - 事件句柄在捕获阶段执行
 */
NW02_jt.prototype.tj_sb_lk = function (ff, useCapture) {
	this.tj('mouseout', ff, useCapture);
}

NW02_jt.prototype.tj_gdt = function (ff) {
	this.tj('scroll', ff, useCapture);
}

NW02_jt.prototype.tj_gdt_gd = function (f_up, f_down) {
	let Dom_even_scrollListener = function (e) {
		e = e || window.event;
		if (e.wheelDelta) { //判断浏览器IE，谷歌滑轮事件               
			if (e.wheelDelta > 0) { //当滑轮向上滚动时  
				f_up();
			}
			if (e.wheelDelta < 0) { //当滑轮向下滚动时  
				f_down();
			}
		} else if (e.detail) { //Firefox滑轮事件  
			if (e.detail > 0) { //当滑轮向下滚动时  
				f_down();
			}
			if (e.detail < 0) { //当滑轮向上滚动时  
				f_up();
			}
		}
	}
	/*IE、Opera注册事件*/
	if (document.attachEvent) {
		document.attachEvent('onmousewheel', Dom_even_scrollListener);
	}
	//Firefox使用addEventListener添加滚轮事件  
	if (document.addEventListener) { //firefox  
		document.addEventListener('DOMMouseScroll', Dom_even_scrollListener, false);
	}
	//Safari与Chrome属于同一类型
	window.onmousewheel = document.onmousewheel = Dom_even_scrollListener;
}
;
///<jscompress sourcefile="_1_sb.js" />

/**
 * 设置【按下鼠标时的事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_ax = function (ff) {
	this.Jiedian.onmousedown = ff;
}

/**
 * 设置【松开】---被按下去的鼠标----时的事件
 * 备注:当释放鼠标按钮时，会触发 onmouseup 事件
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_sk = function (ff) {
	this.Jiedian.onmouseup = ff;
}

/**
 * 设置【点击事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_dj = function (ff) {
	this.Jiedian.onclick = ff;
}

/**
 * 设置【双击事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_sj = function (ff) {
	this.Jiedian.ondblclick = ff;
}

/**
 * 设置【鼠标右击事件】
 * @参数 {function|假值} ff 
 */
NW02_jt.prototype.sb_yj = function (ff) {
	this.Jiedian.oncontextmenu = ff;
}

/**
 * 设置【鼠标移进节点范围的事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_jr = function (ff) {
	this.Jiedian.onmouseover = ff;
}

/**
 * 设置【鼠标移出节点范围的事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.sb_lk = function (ff) {
	this.Jiedian.onmouseout = ff;
}
;
///<jscompress sourcefile="_2_jp.js" />

/**
 * 设置【键盘事件】 按下某个键时触发。
 * @参数 {function|假值} fn 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.jp_ax = function (ff) {
	this.Jiedian.onkeydown = ff;
	this._ngj_jp();
}

/**
 * 设置【键盘事件】 按住某个键不动时时触发。是连续性的触发（不断触发）
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.jp_az = function (ff) {
	this.Jiedian.onkeypress = ff;
	this._ngj_jp();
}

/**
 * 设置【键盘事件】 松开某个按键时触发。触发一次
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.jp_sk = function (ff) {
	this.Jiedian.onkeyup = ff;
	this._ngj_jp();
}

NW02_jt.prototype._ngj_jp = function () {
	let _lx = this.Jiedian.nodeName;
	if (_lx == 'INPUT' || _lx == 'A') {
		return;
	}
	this.jp_kg();
}

//对于div等部分的元件来说，它们需要设置tabindex属性才可能。
//键盘开关
NW02_jt.prototype.jp_kg = function (kg) {
	if (kg == null || kg) {
		if (this.jd.hqSX('tabindex') == null) {
			this.jd.xgSX('tabindex', -1);
			if (this.ys.hqNYS('outline') == null || this.ys.hqNYS('outline') == '') {
				this.ys.xgNYS({ outline: 'none' })
			}
		}
	} else {
		this.jd.scSX('tabindex');
		if (this.ys.hqNYS('outline') == 'none') {
			this.ys.scNYS('outline')
		}
	}

};
///<jscompress sourcefile="_3_zhi.js" />

/**
 * 设置【值 变动事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.z_gb = function (ff) {
	this.Jiedian.onchange = ff;
}

/**
 * 设置【值 输入事件】
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.z_sr = function (ff) {
	this.Jiedian.oninput = ff;
}
;
///<jscompress sourcefile="_4_gdt.js" />
/**
 * 滚动条-滚动事件
 * @参数 {function|假值} ff 如果是函数，会绑定到事件中；如果是【假值】，会删除事件。
 */
NW02_jt.prototype.gdt_gd = function (ff) {
	this.Jiedian.onscroll = ff;
};
///<jscompress sourcefile="_yd_0_cm.js" />
/**
 * 添加 触摸开始事件 方法 ff
 * 
 * @param {对象} Jiedian 节点对象
 * @param {方法} ff 方法
 */
NW02_jt.prototype.cm_ks = function (ff, canshu) {
	this.tj('touchstart', ff, canshu)
}
/**
 * 添加 触摸移动事件 方法 ff
 * 
 * @param {对象} Jiedian 节点对象
 * @param {方法} ff 方法
 */
NW02_jt.prototype.cm_yd = function (ff, canshu) {
	this.tj('touchmove', ff, canshu)
}
/**
 * 添加 触摸结束事件 方法 ff
 * 
 * @param {对象} Jiedian 节点对象
 * @param {方法} ff 方法
 */
NW02_jt.prototype.cm_js = function (ff, canshu) {
	this.tj('touchend', ff, canshu)
}

;
///<jscompress sourcefile="_1_sr.js" />
NW02_zhi.prototype.zhi = function (zhi) {
	let lx = this._ngj_lx();
	switch (lx) {
		//value 输入类型的控件
		case 'INPUT':
			let _sx = this.Jiedian.getAttributeNode('type');
			if (_sx) {
				switch (_sx.value.toLowerCase()) {
					case 'checkbox':
					case 'radio':
						return this._ngj_zhi_v2(zhi);
					default:
						return this._ngj_zhi_v(zhi);
				}
			}
		case 'TEXTAREA':
			return this._ngj_zhi_v(zhi);
		//src 指定路径的 类型的控件
		case 'IMG':
		case 'AUDIO':
			return this._ngj_zhi_src(zhi, lx);
		case 'SELECT':
			let _ezM = this.Jiedian.options;
			if (zhi == undefined) {
				let _a;
				for (i = 0; i < _ezM.length; i++) {
					if (_ezM[i].selected) {
						_a = _ezM[i].getAttributeNode('value');
						return _a ? _a.value : '';
					}
				}
				return null;
			}
			for (i = 0; i < _ezM.length; i++) {
				if (zhi) {
					if (_ezM[i].value == zhi) {  //
						_ezM[i].selected = true;
						return;
					}
				} else if (!_ezM[i].getAttributeNode('value')) {
					_ezM[i].selected = true;
					return;
				}
			}
	}
}

// 假值=不选择；真值=选中；null=取反
NW02_zhi.prototype.sz = function (zhi) {
	if (zhi == undefined) {
		this.Jiedian.checked = !this.Jiedian.checked;
	} else {
		this.Jiedian.checked = zhi ? true : false;
	}
	return this.Jiedian.checked;
}

/**
 * 禁用值
 * @param {真假} zhi 是否禁用。 true=禁；false=不禁；如果zhi为null,则，取反值
 */
NW02_zhi.prototype.jinzhi = function (zhi) {
	if (zhi == null) {
		this.Jiedian.disabled = !this.Jiedian.disabled;
		return this.Jiedian.disabled;
	}
	this.Jiedian.disabled = zhi ? true : false;
	return this.Jiedian.disabled;
}

NW02_zhi.prototype.sc = function () {
	let lx = this._ngj_lx();
	switch (lx) {
		//value 输入类型的控件
		case 'INPUT':
		case 'TEXTAREA':
			this.Jiedian.value = ''
			return;
		//src 指定路径的 类型的控件
		case 'IMG':
		case 'AUDIO':
			this.jd.xgSX('SRC', null);
			this._ngj_audio(lx);
	}

}

//value 输入类型的控件
NW02_zhi.prototype._ngj_zhi_v = function (zhi) {
	if (zhi == undefined) {
		return this.Jiedian.value
	}
	this.Jiedian.value = zhi;
}
NW02_zhi.prototype._ngj_zhi_v2 = function (zhi) {
	if (zhi == undefined) {
		// console.log(this.Jiedian.value)
		return this.Jiedian.value
	}
	if (typeof zhi == 'string') {
		zhi = new Boolean(zhi);
	}
	this.Jiedian.checked = zhi ? true : false;
}

NW02_zhi.prototype._ngj_audio = function (lx) {
	if (lx == 'AUDIO') {
		this.Jiedian.load();
	}
}
//src 指定路径的 类型的控件
NW02_zhi.prototype._ngj_zhi_src = function (zhi, lx) {
	if (zhi == undefined) {
		return this.jd.hqSXzhi('SRC')
	}
	this.jd.xgSX('SRC', zhi);
	this._ngj_audio(lx);
}

NW02_zhi.prototype._ngj_lx = function () {
	let _lx = this.Jiedian.nodeName;
	if (_lx == 'INPUT' && this.Jiedian.type == 'image') {
		return 'IMG';
	}
	return _lx;
};
///<jscompress sourcefile="NW02_zhi.js" />
/**
 * 节点 值 控制 value
 */
function NW02_zhi(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.gj = fq.gj;
    this.wgj = fq.wgj;
    this.Jiedian = fq.Jiedian;
    this.jd = fq.jd;
}
;
///<jscompress sourcefile="NW02.js" />
/**
 * 节点管理 封装对象
 * @参数 {文本|对象} Jiedian  节点
 * @参数 {对象} fq  框架对象——内模块需要从中，获取框架工具的方法
 */
function NW02(Jiedian, fq) {
    this.fq = fq;
    this.gj = new NW02_gj();//工具
    this.wgj = fq.gj;
    this.Jiedian = Jiedian;
    this.Yangshi = this.wgj.hqYangshi(this.Jiedian);

    this.jd = new NW02_jd(this);//节点
    this.ys = new NW02_ys(this);//样式
    this.jt = new NW02_jt(this);//监听
    this.z = new NW02_zhi(this);//值
}

NW02.prototype.sc = function () {
    this.fq.jdzx_sc(this.Jiedian);
}

NW02.prototype.hqJD = function () {
    return this.Jiedian
}

;
///<jscompress sourcefile="NW03_bd.js" />
//本地管理。 访问-本地-功能方法()
/**
 * 总的：
 */

function NW03_bd(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.wgj = fq.wgj;
}


/**
 * 通过目录，删除相关数据（内容+目录）
 * @param {文本} ml 目录
 * @param {文本} cflj 存放路径
 */
NW03_bd.prototype.sc = function (ml, cflj) {
    let shijian = new Date();
    shijian.setTime(shijian.getTime() - 1);
    let _zhi = this.hq(ml);
    if (_zhi != null) {
        cflj = cflj ? ';path=' + cflj : ''
        document.cookie = ml + "=" + _zhi + ";expires=" + shijian.toGMTString() + cflj;
    }
}


/**
 * 保存一对数据 （键=值）。
 * @param {文本} m 键
 * @param {文本|JSON对象} zhi 值
 * @param {数字} bcShijian 天数
 * @param {文本} cflj 存放路径
 */
NW03_bd.prototype.bc = function (m, zhi, bcShijian, cflj) {
    this.bc_pdJM(m, zhi, false, bcShijian, cflj)
}

NW03_bd.prototype.bc_jm = function (m, zhi, bcShijian, cflj) {
    this.bc_pdJM(m, zhi, true, bcShijian, cflj)
}

/**
 * 保存一对数据 （键=值）。 判断是否加密
 * @param {文本} m 键
 * @param {文本|JSON对象} zhi 值
 * @param {数字} bcShijian 天数
 * @param {文本} cflj 存放路径
 */
NW03_bd.prototype.bc_pdJM = function (m, zhi, jiami, bcShijian, cflj) {
    if (!this.wgj.pdWenben(zhi)) {
        zhi = JSON.stringify(zhi);
    }
    cflj = cflj ? ';path=' + cflj : ''
    if (jiami) {
        zhi = this.wgj.jiamiNR(zhi, 11);
    }
    //默认200年
    if (bcShijian == 0) {
        bcShijian = 365 * 200
    } else if (bcShijian == null) {
        bcShijian = undefined;
    }
    let d = new Date();
    d.setTime(d.getTime() + (bcShijian * 24 * 60 * 60 * 1000));
    let expires = ";expires=" + d.toGMTString();

    document.cookie = m + "=" + zhi + expires + cflj;
}

/**
 * 通过目录，取得相关内容（自动 判断，如果是 以{开头 }结束的，会自动转json格式。
 * @param {文本} ml 目录    
 * @param {真假} jiemi 是否需要解密。默认不需要
 * @param {真假} feiZidong 不自动结果转成 Json格式 ； false=自动检测，转换； true=不自动检测
 * @returns 文本|JSON对象
 */
NW03_bd.prototype.hq = function (ml, jiemi, feiZidong) {
    let _m = ml + "=";
    let _SJ = document.cookie.split(';');
    let _jzd;//临时，存放键值对。
    let _jg = '';//如果找到我们需要的值。用此保存
    for (let i = 0; i < _SJ.length; i++) {
        _jzd = _SJ[i].trim();
        if (_jzd.indexOf(_m) == 0) {
            //我们要的结果
            _jg = _jzd.substring(_m.length, _jzd.length);
            //我们的结果是真值，并且需要解密
            if (_jg && jiemi) {
                //执行解密
                _jg = this.wgj.jiemiNR(_jg, 11);
            }
            //不自动转换。直接返结果。
            if (feiZidong) {
                return _jzd;
            }
            break;
        }
    }
    //到这一步，表示需要检测结果，是否是json对象，是的话，转成json对象返回。
    if (_jg) {
        if (_jg.startsWith('{') && _jg.endsWith('}')) {
            return this.wgj.gshWB_mbJson(_jg)
        }
    }
    return _jg;
};
///<jscompress sourcefile="NW03_yc_wj.js" />
function NW03_yc_wj(jd, zsxx, dizih) {
    this.jd = jd;
    this.wjDX = jd.files[0];            // js 获取文件对象

    this.cs_cc = 0;                 // 文件尺寸
    this.cs_jzwhz = true;    //  禁止无后缀的文件 -3
    this.cs_wjhz_hmd = [];   //  文件后缀 黑名单1 阻止
    this.cs_lx_hmd = [];     //  文件类型 黑名单2 阻止
    this.cs_wjhz_bmd = [];   //  文件后缀 白名单  通过
    this.cs_lx_bmd = [];     //  文件类型 白名单  通过

    this.jd_zsxx = zsxx;                // 展示上传信息（过程、结束）的节点
    this.dizih = dizih;                 // 接收上传文件的后台地址
    this.xhr = new XMLHttpRequest();    // XMLHttpRequest 对象
    this.xhr['_wo_sfz'] = this;

    this.sycSJ; //上一次时间
    this.ljZJ;  //累计字节。已经上传了多少字节数据
    this.ff;    //上传结果。用户设置。成功或失败，都会调用这个函数。
    this.zt = null;

    this.hk_shuju = null;//后台返回的文本。
    //成功与失败的代号：比如，数据库返回  {dh:0,cg:'上传失败',dizhi:''}  {dh:1,cg:'上传成功',dizhi:'上传路径...'}
    this.hk_dh = 'dh';

}


NW03_yc_wj.prototype.xsxx = function (xx) {
    if (this.jd_zsxx) {
        this.jd_zsxx.innerHTML = xx;
    }
}


// 0=M 1=kb 2=原始不变。
NW03_yc_wj.prototype.wjcc = function (cc, lx) {
    if (lx == 0 || lx == undefined) {
        this.cs_cc = cc * 1024 * 1024;
        return;
    }
    if (lx == 1) {
        this.cs_cc = cc * 1024
        return;
    }
    this.cs_cc = cc;
}

//  文件类型 黑名单
NW03_yc_wj.prototype.hmd_lx = function (cs) {
    return this._ngj_zhi('cs_lx_hmd', cs)
}
//  文件后缀 黑名单
NW03_yc_wj.prototype.hmd_hz = function (cs) {
    return this._ngj_zhi('cs_wjhz_hmd', cs)
}
//  文件类型 白名单
NW03_yc_wj.prototype.bmd_lx = function (cs) {
    return this._ngj_zhi('cs_lx_bmd', cs)
}
//  文件后缀 白名单
NW03_yc_wj.prototype.bmd_hz = function (cs) {
    return this._ngj_zhi('cs_wjhz_bmd', cs)
}

NW03_yc_wj.prototype._ngj_zhi = function (sx, zhi) {
    if (zhi == undefined) {
        return this[sx];
    }
    if (zhi.indexOf(',')) {
        zhi = zhi.split(',');
        for (let i = 0; i < zhi.length; i++) {
            this[sx].push(zhi[i]);
        }
    } else {
        this[sx].push(zhi);
    }
    return this;
}


NW03_yc_wj.prototype.zbCS = function () {
    //黑名单
    for (let i = 0; i < this.cs_lx_hmd.length; i++) {
        this.cs_lx_hmd[i] = this.hqWJLX(this.cs_lx_hmd[i]);
    }
    //白名单
    for (let i = 0; i < this.cs_lx_bmd.length; i++) {
        this.cs_lx_bmd[i] = this.hqWJLX(this.cs_lx_bmd[i]);
    }
}

NW03_yc_wj.prototype.hqWJLX = function (dh) {
    switch (dh) {
        case 'exe': return 'application/x-msdownload';
        case 'pdf': return 'application/pdf';
        case 'txt': return 'text/plain';
        case 'tar.gz': return 'application/x-gzip';
        case 'zip': return 'application/x-zip-compressed';
        case 'pdf': return ' ';
        case 'jpeg': return 'image/jpeg';
        case 'jpeg': return 'image/png'
        case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
        case 'doc': return 'application/msword';
        case 'xls': return 'application/vnd.ms-excel';
        case 'xlsx': return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';

    }
}


NW03_yc_wj.prototype.zxff = function (dh) {
    if (this.ff) {
        this.ff(dh, this)
    }
}


//停止
NW03_yc_wj.prototype.tz = function () {
    this.xhr.abort();
}

//0）如果配置了文件最大值，先检查文件尺寸。不符合，即可阻止
//1）只要在黑名单，即可阻止。
//2）在白名单，ok
//3）不在黑名单，也不在白单名（如果 白名单 非空），同样阻止。
//4) 没有配置黑名单、白名单。直接通过。 

//true=校验出错，不通过; false=校验通过
NW03_yc_wj.prototype.cw = function () {
    if (!this.wjDX) {
        this.zxff(-2);
        this.xsxx('【请选择文件】')
        return true;
    }
    //0）如果配置了文件最大值，先检查文件尺寸。不符合，即可阻止
    //比如，文件20M > 我配置了10M，阻止上传
    if (this.cs_cc > 0 && this.wjDX.size > this.cs_cc) {
        // console.log('超出文件尺寸范围。' + this.cs_cc + '   文件=' + this.wjDX.size)
        this.zxff(-3);
        this.xsxx('超出文件尺寸范围:' + ((this.wjDX.size - this.cs_cc) / 1024 / 1024).toFixed(3) + 'M')
        return true;
    }
    //1）只要在黑名单，即可阻止。
    //黑名单 
    if (this._ngj_pdZhi('cs_lx_hmd', this.wjDX.type)) {
        this.xsxx('【文件类型】在 黑单名里面')
        this.zxff(-3);
        return true;
    }

    let mz = this.wjDX.name;
    let hz = mz.lastIndexOf('.') == -1 ? null : mz.substring(mz.lastIndexOf('.') + 1);
    if (!hz && this.cs_jzwhz) {//文件没有后缀，又禁止没有后缀的文件上传,则，禁止上传
        return true;
    }

    //黑名单 如果存在后缀
    if (this._ngj_pdZhi('cs_wjhz_hmd', hz)) {
        this.xsxx('【文件后缀】（' + hz + '） 在 黑名单里面')
        this.zxff(-3);
        return true;
    }
    //2）在白名单，ok
    //白名单 
    if (this._ngj_pdZhi('cs_lx_bmd', this.wjDX.type)) {
        // console.log('在 【类型白单名】里面。通过')
        return false;
    }

    //白名单 
    if (this._ngj_pdZhi('cs_wjhz_bmd', hz)) {
        // console.log('在 【后缀白单名】里面。通过')
        return false;
    }

    //3）不在黑名单，也不在白单名（如果 白名单 非空），同样阻止。
    if (this.cs_wjhz_bmd.length > 0 || this.cs_lx_bmd.length > 0) {
        // console.log('已经配置了白名单，但此文件不在 【不在白名单】 里面，阻止')
        this.xsxx('文件不在 【白名单】 里面')
        this.zxff(-3);
        return true;//阻止
    }
    //4) 没有配置黑名单、白名单。直接通过。 
    return false;
}

NW03_yc_wj.prototype._ngj_pdZhi = function (sx, zhi) {
    let sz = this[sx];
    for (let i = 0; i < sz.length; i++) {
        if (sz[i] == zhi) {
            return true;
        }
    }
    return false;
}



//上传方法
NW03_yc_wj.prototype.qd0 = function (ff, tb) {
    let wo = this;
    if (ff) {
        this.ff = ff;
    }
    // console.log('----------------------------------')
    this.zbCS()
    if (this.cw()) {
        return;
    }

    this.xhr.open("post", this.dizih, tb ? tb : true);  //post方式，url为服务器请求地址，true 该参数规定请求是否异步处理。

    this.xhr.onload = this._sqjg_cg;                    //请求完成
    this.xhr.onerror = this._sqjg_sb;                   //请求失败

    this.xhr.upload['_wo_sfz'] = this;

    this.bdDX = new FormData();                         // FormData 对象
    this.bdDX.append("file", this.wjDX);                // 文件对象
    this.xhr.upload.onprogress = this._scgc;            //【上传进度调用方法实现】
    this.xhr.upload.onloadstart = function () {         //上传开始执行方法
        wo.zt = null;
        wo.sycSJ = new Date().getTime();                //记录上传时间-开始
        wo.ljZJ = 0;                                    //设置上传开始时，以上传的文件大小为0
        wo.hk_shuju = null;
    };
    this.xhr.send(this.bdDX); //开始上传，发送form数据
}

//上传过程
NW03_yc_wj.prototype._scgc = function (e) {
    // let wo = nw.ff.yc.hqWJ(jd);
    let wo = e.currentTarget._wo_sfz;
    if (!wo.jd_zsxx) {
        return;
    }
    let hkxx = ''
    // e.total是需要传输的总字节，
    // e.loaded是已经传输的字节。
    // e.lengthComputable 不为真，则 e.total 等于0
    if (e.lengthComputable) {
        hkxx = Math.round(e.loaded / e.total * 100) + "%，";
    }
    let pertime = (new Date().getTime() - wo.sycSJ) / 1000; //计算出上次调用该方法时到现在的时间差，单位为s
    wo.sycSJ = new Date().getTime();        //重新赋值时间，用于下次计算
    let zlZJ = e.loaded - wo.ljZJ;          //针对累计的上传字节，现在，所【增量字节】
    wo.ljZJ = e.loaded;                     //重新赋值已上传文件大小，用以下次计算
    //上传速度计算
    let _sd = zlZJ / pertime;//单位b/s
    let _sd2 = _sd;
    let _dw = 'b/s';//单位名称
    if (_sd / 1024 > 1) {
        _sd = _sd / 1024;
        _dw = 'k/s';
    }
    if (_sd / 1024 > 1) {
        _sd = _sd / 1024;
        _dw = 'M/s';
    }
    _sd = _sd.toFixed(1);

    if (wo.ljZJ == 0) {
        wo.jd_zsxx.innerHTML = '无法上传'
    } else {
        wo.jd_zsxx.innerHTML = hkxx + '速度：' + _sd + _dw + '，剩余时间：' + (((e.total - e.loaded) / _sd2).toFixed(1)) + '秒';
    }
    if (_sd2 == 0) {
        wo.jd_zsxx.innerHTML = '上传已取消';
    }
}

NW03_yc_wj.prototype._sqjg_sb = function (e) {
    let wo = e.currentTarget._wo_sfz;
    wo.zt = 0;
    if (!e.target.responseText) {
        wo.zt = -1;
        wo.xsxx('<<<<<上传异常>>>>>')
    } else {
        wo.xsxx('<<<<<上传失败>>>>>')
    }

    wo.zxff(wo.zt);
}

//上传结果
NW03_yc_wj.prototype._sqjg_cg = function (e) {
    let wo = e.currentTarget._wo_sfz;
    let mb = e.target
    if (!mb.responseText) {
        wo.xsxx('<<<<<上传异常>>>>>')
        wo.zt = -1;
    } else {
        wo.hk_shuju = JSON.parse(mb.responseText);
        if (wo.hk_shuju && wo.hk_shuju[wo.hk_dh]) {
            wo.xsxx('上传成功')
            wo.zt = 1;
        } else {
            wo.zt = 0;
            wo.xsxx('<<<<<上传失败>>>>>')
        }
    }
    wo.zxff(wo.zt);
};
///<jscompress sourcefile="NW03_yc.js" />
function NW03_yc(fq) {//传入父亲对象（本对象的上一级）
    this.fq = fq;
    this.wgj = fq.wgj;

    // this.hc = [];//缓存对象。用于： NW03_yc_wj


    //报文_格式
    this.bw_gs = {
        json: 'application/json; charset=utf-8',
        j: this.json,
        text: 'application/x-www-form-urlencoded',
        wb: this.text,
        w: this.text
    }
}
NW03_yc.prototype.post = this.by
NW03_yc.prototype.get = this.n
/**
 * 
 * 搬运（by）数据
 * ajax请求，post方式
 * @参数 {对象} dizhi 请求路径 
 * @参数 {对象} Canshu 参数
 * @参数 {对象} ff 请求成功后，回调函数
 * @参数 {对象} shujuLX 数据类型
 * @参数 {boolean} yibu true=异步（默认） ，false=同步
 */
NW03_yc.prototype.by = function (dizhi, canshu, ff, shujuLX, yibu) {
    canshu = this._ngj_bw_canshu(canshu);
    this._ngj_ajax('post', dizhi, canshu, ff, shujuLX, yibu);
}

// NW03_yc.prototype.hqWJ = function (jd) {
//     for (let i = 0; i < this.hc.length; i++) {
//         if (this.hc[i].jd == jd) {
//             return this.hc[i];
//         }
//     }
//     return null;
// }

NW03_yc.prototype.cjWJ = function (jd, zsxx, dizih) {
    // let wj = new NW03_yc_wj(jd, zsxx, dizih);
    if (typeof jd == 'string') {
        jd = document.getElementById(jd);
    }
    if (typeof zsxx == 'string') {
        zsxx = document.getElementById(zsxx);
    }
    return new NW03_yc_wj(jd, zsxx, dizih);
}


NW03_yc.prototype.by_j = function (dizhi, canshu, ff, yibu) {
    this.by(dizhi, canshu, ff, 'json', yibu);
}
NW03_yc.prototype.hq_j = function (fs, dizhi, canshu, ff, yibu) {
    this.hq(fs, dizhi, canshu, ff, 'json', yibu)
}
NW03_yc.prototype.n_j = function (dizhi, canshu, ff, yibu) {
    this.n(dizhi, canshu, ff, 'json', yibu)
}

NW03_yc.prototype.hq = function (fs, dizhi, canshu, ff, shujuLX, yibu) {
    if (null == fs) {
        fs = 'post';
    } else if (this.wgj.pdWenben(fs)) {
        fs = this.wgj.scKong(fs).toLowerCase();

    }

    switch (fs) {
        default:
        case 'post':
        case 'by':
        case '1':
        case 1:
            this.by(dizhi, canshu, ff, shujuLX, yibu)
            return;
        case 'get':
        case 'n':
        case '0':
        case 0:
            this.n(dizhi, canshu, ff, shujuLX, yibu)
            return;
    }
}


/**
 * 拿（n)数据。
 * ajax请求，get方式
 * @参数 {对象} dizhi 请求路径 
 * @参数 {对象} canshu 参数
 * @参数 {对象} ff 请求成功后，回调函数
 * @参数 {对象} shujuLX 数据类型
 * @参数 {boolean} yibu true=异步（默认），false=同步 
 */
NW03_yc.prototype.n = function (dizhi, canshu, ff, shujuLX, yibu) {
    //参数管理
    canshu = this._ngj_bw_canshu(canshu); //将参数，调整成 【报文】要求的【样子】
    if (canshu) {
        dizhi = dizhi + '?' + canshu; //如果有参数，附加到url上。因为是get方式请求。
    }
    this._ngj_ajax('get', dizhi, null, ff, shujuLX, yibu);
}



//--------------------------工具管理--------------------------
//反馈
NW03_yc.prototype._zx_fk = function (ff, jg) {
    if (ff) {
        if (typeof ff == 'function') {//如果传入的是函数
            ff(jg);
            return;
        }
        if (ff['_03yc_qq_cg']) {
            ff._03yc_qq_cg(jg);
        }
    }
}
// js ajax技术
NW03_yc.prototype._ngj_ajax = function (lx, dizhi, canshu, ff, shujuLX, yibu) {
    shujuLX = this._ngj_bw_gs(shujuLX); //将参数，调整成 【报文】要求的【样子】
    //1、取得ajax对象
    let xmlhttp = this.wgj.hqXMLHttpRequest();
    //2、添加监听——ajax技术。浏览会不断检测反馈结果，并动态调用（当条件满足后）相关的方法
    let _wgj = this.wgj;
    let wo = this;
    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
            if (ff) {
                switch (shujuLX) {
                    case 'j':
                    case 'json':
                        wo._zx_fk(ff, _wgj.gshWB_mbJson(xmlhttp.responseText))
                        break;
                    case 'text':
                    case 'wb':
                    case 'w':
                        // ff(xmlhttp.responseText);
                        wo._zx_fk(ff, xmlhttp.responseText)
                        break;
                    default:
                        // ff(xmlhttp.responseText);
                        wo._zx_fk(ff, xmlhttp.responseText)
                        break;
                }
            }
        }
    }
    //3、创建【大路】通向服务器 lx=post|get ；dizhi=服务器地址；yibu=true|false
    xmlhttp.open(lx, dizhi, yibu == undefined ? true : yibu);
    //4、准备报文（报告 服务器 的文章） 头（标题）。
    this._ngj_bw_tou(xmlhttp, shujuLX);
    //5、提交报文（标题+内容）
    xmlhttp.send(canshu);//post

    // if (canshu) {
    //     xmlhttp.send(canshu);//post
    // } else {
    //     xmlhttp.send(); //get
    // }
}

/**
 * 辅助:设置请求头-内容格式(配置pz 访问FW 头tou)
 * @参数 {对象} xmlhttp ajax对象
 * @参数 {对象} shujuLX 数据类型
 */
NW03_yc.prototype._ngj_bw_tou = function (xmlhttp, shujuLX) {
    for (let key in this.bw_gs) {
        if (shujuLX == key) {
            xmlhttp.setRequestHeader('Content-Type', this.bw_gs[key]);
            return;
        }
    }
    xmlhttp.setRequestHeader('Content-Type', this.bw_gs['json']);
}


/**
 * 工具:格式化数据类型(格式化gsh 返回值FHZ 的类型 LX)
 * 默认是json类型
 * 统一小写，去除多余的空格。
 * 
 * @参数 {对象} rDataType 数据类型
 */
NW03_yc.prototype._ngj_bw_gs = function (shujuLX) {
    return shujuLX ? this.wgj.scKong(shujuLX).toLowerCase() : 'json'; //去除空格，并全部小写。
}

/**
 * 将参数，调整成 【报文】要求的【样子】
 * 格式化地址（DiZhi)参数(canshu),使其变成"参数1=1&参数2=xx............"的格式。
 * @参数 {String|Object} dizhiShuju 路径参数
 */
NW03_yc.prototype._ngj_bw_canshu = function (dizhiShuju) {
    if (null == dizhiShuju || undefined == dizhiShuju) {
        return '';
    }
    //传入来的是字符串时
    if (this.wgj.pdWenben(dizhiShuju)) {
        return this.wgj.scKong(dizhiShuju);
    }
    return this.wgj.dx_z_wb(dizhiShuju);
};
///<jscompress sourcefile="NW03.js" />
function NW03(fq) {//传入父亲对象（本对象的上一级）
	this.fq = fq;
	this.wgj = fq.gj;

	this.yc = new NW03_yc(this);	//远程访问
	this.bd = new NW03_bd(this);	//本地管理
}

;
///<jscompress sourcefile="NW04_rw_ys.js" />
// 延时任务管理
function NW04_rw_ys(fq) {
    this.fq = fq;
    //专门存放 需要【延时】的任务； 存放的是个体： NW04_rw_ys_gt 
    this.rwzx = [];
    this.jygz = /^_0402_ys[\da-zA-Z_]*_{1}[0-9]+$/
}

/**
 * 从对象中，分析出延时任务。然后，创建一个任务，并保存任务。
 * 
 *    从对象属性中，分析出我们的延时任务
 *    【ff】符合这条规则的，即为延时任务-执行方法：   [_0402_ys][_可选字符]_[纯数字]
 *    【zt】并且，控制任务状态的，即为               [_0402_ys][_可选字符]    如果没有，自动生成。并附值为 1   ; 0停止状态； 1表示通行状态（任务只能工作在 通行状态）
 *    【sj】并且，得到延时执行的时间为               [纯数字]
 * 
 *    比如：
 *    _0402_ys_200
 *    _0402_ys
 * @param {对象} RWdx 需要被
 */
NW04_rw_ys.prototype.tjRW = function (RWdx) {
    let _yb_haomiao;//毫秒前_的游标。 
    let _sj;
    let _ztMing;
    for (let ffm in RWdx) {
        // console.log(typeof ffm === "function")
        if (this.jygz.test(ffm) ) {//检查是否符合我们的规则。并且是函数。
            _yb_haomiao = ffm.lastIndexOf('_');
            // ffm= _0402_ys_个性化_200
            _sj = parseInt(ffm.substring(_yb_haomiao + 1));  //  200
            _ztMing = ffm.substring(0, _yb_haomiao)          //  _0402_ys_个性化
            if (RWdx[_ztMing] == undefined) {
                RWdx[_ztMing] = 1;//创建属性，并附值为1：通行状态
            }
            this.rwzx.push(new NW04_rw_ys_gt(_sj, RWdx, ffm, _ztMing));//创建一个任务个体：将分析出来的 任务参数，保存起来。
        }
    }
}


/**
 * 执行延时
 * @param {整数} yanchi 延时时间
 * @param {对象} dx 定时执行ff方法的对象
 * @param {文本} ff dx里面的方法名。每延时yanchi毫秒，就会执行一次 dx[ff]();
 */
NW04_rw_ys.prototype.qd = function () {
    for (let i = 0; i < this.rwzx.length; i++) {
        this.rwzx[i].qd();
    }
};
///<jscompress sourcefile="NW04_rw_ys_gt.js" />
//个体：延时任务 封装。
function NW04_rw_ys_gt(sj, dx, ff, zt) {
    this.dx = dx;//对象
    this.zt = zt;//任务状态。比如为 'abc', 即，控制状态的值为：  this.dx['abc']
    this.ff = ff;//方法名
    this.sj = sj;//延时时间，毫秒
    this.qdzt = 0;//启动状态; 1表示已经启动。0表示还没有启动。
}

//启动任务
NW04_rw_ys_gt.prototype.qd = function () {
    //如果 已经处于启动状态，或者是 任务状态 为假——非通行状态时，不能开始任务！
    if (this.qdzt || !this.dx[this.zt]) {
        return;//已经启动了，不用再启动了。
    }
    this.qdzt = 1;
    let _dx = this.dx;
    let _zt = this.zt;
    let _ff = this.ff;
    let _yanchi = this.sj;

    setTimeout(function () {
        _dx[_ff]();
        if (_dx[_zt]) {//只工作在 通行状态
            setTimeout(arguments.callee, _yanchi);
        } else {
            //进入非工作状态后
            this.qdzt = 0;//表示任务已经停止下来
        }
    }, _yanchi);
}

;
///<jscompress sourcefile="NW04_rw.js" />
// _0402_ys_200
function NW04_rw(fq) {
    this.fq = fq;
    this.ysRWzx = new NW04_rw_ys(this);//专门   处理延时任务的
}

NW04_rw.prototype.tjYanshiRW = function (dxSZ) {
    if (dxSZ.constructor === Array) {
        for (let i = 0; i < dxSZ.length; i++) {
            this.ysRWzx.tjRW(dxSZ[i]);
        }
    } else {
        this.ysRWzx.tjRW(dxSZ);
    }
}

/**
 * 执行延时
 * @param {整数} yanchi 延时时间
 * @param {对象} dx 定时执行ff方法的对象
 * @param {文本} ff dx里面的方法名。每延时yanchi毫秒，就会执行一次 dx[ff]();
 */
NW04_rw.prototype.qd = function () {
    this.ysRWzx.qd();
};
///<jscompress sourcefile="NW04_jt_fz.js" />
function NW04_jt_fz(SZ, jd, e) {
    for (let i = 0; i < SZ.length; i++) {
        SZ[i].zx(jd, e)
    }
}

// 【按下鼠标时的事件】
function NW04_jt_fz_sb_ax(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.anxia, this, e)
}

// 【松开】---被按下去的鼠标----时的事件
function NW04_jt_fz_sb_sk(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.songkai, this, e)
}

// 【点击事件】
function NW04_jt_fz_sb_dj(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.danji, this, e)
}

// 【双击事件】
function NW04_jt_fz_sb_sj(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.shuangji, this, e)
}

// 【鼠标右击事件】
function NW04_jt_fz_sb_yj(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.youji, this, e)
}

// 【鼠标移进节点范围的事件】
function NW04_jt_fz_sb_jr(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.yijin, this, e)
}

// 【鼠标移出节点范围的事件】
function NW04_jt_fz_sb_lk(e) {
    NW04_jt_fz(nw.yq.jt.pz_sb.yichu, this, e)
}
//---------------------------
// 【键盘事件】 按下某个键时触发
function NW04_jt_fz_jp_ax(e) {
    NW04_jt_fz(nw.yq.jt.pz_jp.anxia, this, e)
}
// 【键盘事件】 按住某个键不动时时触发
function NW04_jt_fz_jp_az(e) {
    NW04_jt_fz(nw.yq.jt.pz_jp.anzhu, this, e)
}
// 【键盘事件】 按住某个键不动时时触发
function NW04_jt_fz_jp_sk(e) {
    NW04_jt_fz(nw.yq.jt.pz_jp.songkai, this, e)
}

//---------------------------
// 【值-改变】 
function NW04_jt_fz_z_gb(e) {
    NW04_jt_fz(nw.yq.jt.pz_zhi.gaibian, this, e)
}
// 【值-输入】 
function NW04_jt_fz_z_sr(e) {
    NW04_jt_fz(nw.yq.jt.pz_zhi.shuru, this, e)
}
//---------------------------
// 【滚动条】 
function NW04_jt_fz_gdt_gd(e) {
    NW04_jt_fz(nw.yq.jt.pz_gdt.gundong, this, e)
}

//---------------------------
// 【触摸】 
function NW04_jt_fz_cm_ks(e) {
    NW04_jt_fz(nw.yq.jt.pz_cm.ks, this, e)
}
function NW04_jt_fz_cm_yd(e) {
    NW04_jt_fz(nw.yq.jt.pz_cm.yd, this, e)
}
function NW04_jt_fz_cm_js(e) {
    NW04_jt_fz(nw.yq.jt.pz_cm.js, this, e)
}

function NW04_jt_fz_ck_gb() {
    NW04_jt_fz(nw.yq.jt.pz_ck.gb);
};
///<jscompress sourcefile="NW04_jt.js" />
// 监听引擎。为用户提供方便、智能的监听 
// 
//  _0403 表示监听
//  _0403_(sb|jp|zhi|gdt)_运作_节点id
// 
// 节点id   与事件方法分开写
// _0403_sb_dj_zj="ABC" 表示要监听的 节点id=ABC
// _0403_sb_dj  表示单击事件发生后，调用的方法

// 事件方法_节点id
// _0403_sb_dj_节点id
// 
function NW04_jt(fq) {
    this.nwDX = fq.fq;
    this.fq = fq;
    this.mrJD = '_jd';
    //存放 鼠标-单击 配置{主键,dx,dx.ffm}
    this.pz_sb = {
        anxia: [],      //【按下鼠标时的事件】
        songkai: [],    //【松开】---被按下去的鼠标----时的事件
        danji: [],      //【点击事件】
        shuangji: [],   //【双击事件】
        youji: [],      //【鼠标右击事件】
        yijin: [],      //【鼠标移进节点范围的事件】
        yichu: []       //【鼠标移出节点范围的事件】
    }

    this.pz_jp = {
        anxia: [],          //【按下】
        anzhu: [],          //【按住】 
        songkai: []         //【松开】 
    }

    this.pz_zhi = {
        gaibian: [],            //【值改变】
        shuru: []               //【值输入】 
    }

    this.pz_gdt = {
        gundong: []               //【滚动条】 
    }

    this.pz_cm = {
        ks: [],          //【开始】
        yd: [],          //【移动】 
        js: []           //【结束】 
    }

    this.pz_ck = {
        gb: []           //【结束】 
    }

    this.sbjt = new NW04_jt_sb(this);
    this.jpjt = new NW04_jt_jp(this);
    this.zhijt = new NW04_jt_zhi(this);
    this.gdtjt = new NW04_jt_gdt(this);
    this.cmjt = new NW04_jt_cm(this);
    this.ckjt = new NW04_jt_ck(this);
}

//监听用户对象；需要分析对象里面的配置。然后，根据配置，调用 tjRWdx 来创建一个监听任务
NW04_jt.prototype.jt = function (dx) {
    this.sbjt.tjRW(dx);//监听鼠标的事件。
    this.jpjt.tjRW(dx);
    this.zhijt.tjRW(dx);
    this.gdtjt.tjRW(dx);
    this.cmjt.tjRW(dx);
    this.ckjt.tjRW(dx)
}

/**
 * 添加一个监听任务 对象
 * @param {文本} jd_zj 节点id
 * @param {文本} ffm 方法名
 * @param {对象} dx 对象   当监听到节点事件时，框架会自动调用  dx[ffm](参数) 
 * @param {文本} lx 类型
 */
NW04_jt.prototype.tjRWdx = function (jd_zj, ffm, dx, lx) {
    let _nwDX = null;
    if (jd_zj) {
        _nwDX=this.nwDX.cj(jd_zj);
    }
    let _RW = new NW04_jt_gt(_nwDX, dx, ffm);//个体  封装（类型bean）
    switch (lx) {
        case 'sb_ax':
            this.pz_sb.anxia.push(_RW)//缓存 个体。方便调用
            _nwDX.jt.sb_ax(NW04_jt_fz_sb_ax); break;//创建 监听事件 触发后，会自动调用 NW04_jt_fz_sb_ax 函数
        case 'sb_sk':
            this.pz_sb.songkai.push(_RW)
            _nwDX.jt.sb_sk(NW04_jt_fz_sb_sk); break;
        case 'sb_dj':
            this.pz_sb.danji.push(_RW)
            _nwDX.jt.sb_dj(NW04_jt_fz_sb_dj); break;
        case 'sb_sj':
            this.pz_sb.shuangji.push(_RW)
            _nwDX.jt.sb_sj(NW04_jt_fz_sb_sj); break;
        case 'sb_yj':
            this.pz_sb.youji.push(_RW)
            _nwDX.jt.sb_yj(NW04_jt_fz_sb_yj); break;
        case 'sb_jr':
            this.pz_sb.yijin.push(_RW)
            _nwDX.jt.sb_jr(NW04_jt_fz_sb_jr); break;
        case 'sb_lk':
            this.pz_sb.yichu.push(_RW)
            _nwDX.jt.sb_lk(NW04_jt_fz_sb_lk); break;

        //监听键盘
        case 'jp_ax'://按下 
            this.pz_jp.anxia.push(_RW);
            _nwDX.jt.jp_ax(NW04_jt_fz_jp_ax); break;
        case 'jp_az': //按住不动
            this.pz_jp.anzhu.push(_RW);
            _nwDX.jt.jp_az(NW04_jt_fz_jp_az); break;
        case 'jp_sk'://松开
            this.pz_jp.songkai.push(_RW);
            _nwDX.jt.jp_sk(NW04_jt_fz_jp_sk); break;

        //值监听
        case 'z_gb': //【值-改变】
            this.pz_zhi.gaibian.push(_RW);
            _nwDX.jt.z_gb(NW04_jt_fz_z_gb); break;
        case 'z_sr':   //【值-输入】 
            this.pz_zhi.shuru.push(_RW);
            _nwDX.jt.z_sr(NW04_jt_fz_z_sr); break;

        // 滚动条
        case 'gdt_gd': //【滚动条】 
            this.pz_gdt.gundong.push(_RW);
            _nwDX.jt.gdt_gd(NW04_jt_fz_gdt_gd); break;

        // 触摸
        case 'cm_ks': //【触摸开始事件】 
            this.pz_cm.ks.push(_RW);
            _nwDX.jt.cm_ks(NW04_jt_fz_cm_ks); break;

        case 'cm_yd': //【触摸移动事件】 
            this.pz_cm.yd.push(_RW);
            _nwDX.jt.cm_yd(NW04_jt_fz_cm_yd); break;

        case 'cm_js': //【触摸移动事件】 
            this.pz_cm.js.push(_RW);
            _nwDX.jt.cm_js(NW04_jt_fz_cm_js); break;

        // 窗口事件
        case 'ck_gb':
            this.pz_ck.gb.push(_RW);
            break;
    }
};
///<jscompress sourcefile="NW04_jt_gt.js" />
function NW04_jt_gt(jd, dx, ffm) {
    //被监听的节点
    this.jd = jd;
    this.dx = dx;//nw节点对象
    this.ffm = ffm;
}


NW04_jt_gt.prototype.zx = function (jd, e) {
    if (this.jd) {
        if (this.jd.Jiedian == jd) {
            this.dx[this.ffm](this.jd, e)
        }
    } else {
        //比如窗口监听
        this.dx[this.ffm]();
    }
}


;
///<jscompress sourcefile="NW04_jt_sb.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_sb(fq) {
    this.fq = fq;
    //默认节点id
    this.mrJD = fq.mrJD;
    // 鼠标事件-纯方法名。
    this.sb = /^_0403_sb_(ax|sk|dj|sj|yj|jr|lk){1}$/i
    this.sbHzj = /^_0403_sb_(ax|sk|dj|sj|yj|jr|lk)_[0-9a-z_]+$/i
    //监听【类型列表】
    this.lxLB = ['sb_ax', 'sb_sk', 'sb_dj', 'sb_sj', 'sb_yj', 'sb_jr', 'sb_lk']
    this.ffqz = [
        '_0403_sb_ax',
        '_0403_sb_sk',
        '_0403_sb_dj',
        '_0403_sb_sj',
        '_0403_sb_yj',
        '_0403_sb_jr',
        '_0403_sb_lk'
    ]
}

NW04_jt_sb.prototype.tjRW = function (dx) {
    let _jt_id;
    let _mrjd = dx[this.mrJD];
    for (let ffm in dx) {

        //如果方法是 监听 要调用的方法（纯方法。没有配置节点id在里面）
        if (this.sb.test(ffm)) {
            _jt_id = dx[ffm + 'zj'];//方法监听 节点的id值
            //判断此方法的要监听的 节点
            if (!_jt_id) {//如果不存在这个属性，表示用户没有配置专门的节点id。检测是否配置了默认节点id，如果没有配置，表明这不是监听方法。
                if (!_mrjd) {//没有配置默认节点
                    continue;//下一个方法。这个方法不是监听方法。
                }
                _jt_id = _mrjd;
            }
            //找齐了一个配置。监听节点id、 方法名、对象、方法归属哪种监听；将分析结束，放入到父容器中保存（以监听任务形式）
            // console.log('1方法名='+ffm + ",类型=" + this.hqLX(ffm) + ',主键=' + _jt_id)
            this.fq.tjRWdx(_jt_id, ffm, dx, this.hqLX(ffm));//添加【监听作业】。
            continue;
        }
        //如果 方法是由 
        // _0403_sb_(ax|sk|dj|sj|yj|jr|lk)_[0-9a-z_]/i 组成：
        if (this.sbHzj.test(ffm)) {
            // console.log('2方法名='+ffm + ",类型=" + this.hqLX(ffm) + ',主键=' + this.hqZJ(ffm))
            this.fq.tjRWdx(this.hqZJ(ffm), ffm, dx, this.hqLX(ffm));
        }
    }
}
//从方法名，分析出 本方法要绑定在 哪种事件。 比如：单击、右右......

NW04_jt_sb.prototype.hqLX = function (ffm) {
    ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    for (let i = 0; i < this.lxLB.length; i++) {
        // 因为方法名前缀，都是 _0403_ 所以，(ax|sk|dj|sj|yj|jr|lk)必须从6位开始
        if (ffm.indexOf(this.lxLB[i]) == 6) {
            return this.lxLB[i];
        }
    }
}

//从方法名中，提供id.
NW04_jt_sb.prototype.hqZJ = function (ffm) {
    let _ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    let _qj;
    for (let i = 0; i < this.ffqz.length; i++) {
        _qj = this.ffqz[i];
        if (_ffm.startsWith(_qj)) {//如果方法名以 _0403_sb_(ax|sk|dj|sj|yj|jr|lk) 开始
            return ffm.substring(_qj.length + 1);
        }
    }
}


;
///<jscompress sourcefile="NW04_jt_jp.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_jp(fq) {
    this.fq = fq;
    //默认节点id
    this.mrJD = fq.mrJD;
    // 鼠标事件-纯方法名。
    this.jp = /^_0403_jp_(ax|sk|az){1}$/i
    this.jpHzj = /^_0403_jp_(ax|sk|az)_[0-9a-z_]+$/i
    //监听【类型列表】
    this.lxLB = ['jp_ax', 'jp_sk', 'jp_az']
    //方法前缀
    this.ffqz = [
        '_0403_jp_ax',
        '_0403_jp_sk',
        '_0403_jp_az'
    ]
}

NW04_jt_jp.prototype.tjRW = function (dx) {
    let _jt_id;
    let _mrjd = dx[this.mrJD];
    for (let ffm in dx) {

        //如果方法是 监听 要调用的方法（纯方法。没有配置节点id在里面）
        if (this.jp.test(ffm)) {
            _jt_id = dx[ffm + 'zj'];//方法监听 节点的id值
            //判断此方法的要监听的 节点
            if (!_jt_id) {//如果不存在这个属性，表示用户没有配置专门的节点id。检测是否配置了默认节点id，如果没有配置，表明这不是监听方法。
                if (!_mrjd) {//没有配置默认节点
                    continue;//下一个方法。这个方法不是监听方法。
                }
                _jt_id = _mrjd;
            }
            //找齐了一个配置。监听节点id、 方法名、对象、方法归属哪种监听；将分析结束，放入到父容器中保存（以监听任务形式）
            // console.log('1方法名='+ffm + ",类型=" + this.hqLX(ffm) + ',主键=' + _jt_id)
            this.fq.tjRWdx(_jt_id, ffm, dx, this.hqLX(ffm));//添加【监听作业】。
            continue;
        }
        //如果 方法是由 
        // _0403_jp_(ax|sk|az)_[0-9a-z_]/i 组成：
        if (this.jpHzj.test(ffm)) {
            this.fq.tjRWdx(this.hqZJ(ffm), ffm, dx, this.hqLX(ffm));
        }
    }
}
//从方法名，分析出 本方法要绑定在 哪种事件。 比如：单击、右右......

NW04_jt_jp.prototype.hqLX = function (ffm) {
    ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    for (let i = 0; i < this.lxLB.length; i++) {
        // 因为方法名前缀，都是 _0403_ 所以，(ax|sk|az)必须从6位开始
        if (ffm.indexOf(this.lxLB[i]) == 6) {
            return this.lxLB[i];
        }
    }
}

//从方法名中，提供id.
NW04_jt_jp.prototype.hqZJ = function (ffm) {
    let _ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    let _qj;
    for (let i = 0; i < this.ffqz.length; i++) {
        _qj = this.ffqz[i];
        if (_ffm.startsWith(_qj)) {//如果方法名以 _0403_jp_(ax|sk|az) 开始
            return ffm.substring(_qj.length + 1);
        }
    }
}


;
///<jscompress sourcefile="NW04_jt_zhi.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_zhi(fq) {
    this.fq = fq;
    //默认节点id
    this.mrJD = fq.mrJD;
    // 鼠标事件-纯方法名。
    this.zhiFFM = /^_0403_z_(gb|sr){1}$/i
    this.zhiFFMHzj = /^_0403_z_(gb|sr)_[0-9a-z_]+$/i
    //监听【类型列表】
    this.lxLB = ['z_gb', 'z_sr']
    //方法前缀
    this.ffqz = [
        '_0403_z_gb',
        '_0403_z_sr'
    ]
}

NW04_jt_zhi.prototype.tjRW = function (dx) {
    let _jt_id;
    let _mrjd = dx[this.mrJD];
    for (let ffm in dx) {

        //如果方法是 监听 要调用的方法（纯方法。没有配置节点id在里面）
        if (this.zhiFFM.test(ffm)) {
            _jt_id = dx[ffm + 'zj'];//方法监听 节点的id值
            //判断此方法的要监听的 节点
            if (!_jt_id) {//如果不存在这个属性，表示用户没有配置专门的节点id。检测是否配置了默认节点id，如果没有配置，表明这不是监听方法。
                if (!_mrjd) {//没有配置默认节点
                    continue;//下一个方法。这个方法不是监听方法。
                }
                _jt_id = _mrjd;
            }
            //找齐了一个配置。监听节点id、 方法名、对象、方法归属哪种监听；将分析结束，放入到父容器中保存（以监听任务形式）
            this.fq.tjRWdx(_jt_id, ffm, dx, this.hqLX(ffm));//添加【监听作业】。
            continue;
        }
        //如果 方法是由 
        // _0403_z_(gb|sr)_[0-9a-z_]/i 组成：
        if (this.zhiFFMHzj.test(ffm)) {
            this.fq.tjRWdx(this.hqZJ(ffm), ffm, dx, this.hqLX(ffm));
        }
    }
}
//从方法名，分析出 本方法要绑定在 哪种事件。 比如：单击、右右......

NW04_jt_zhi.prototype.hqLX = function (ffm) {
    ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    for (let i = 0; i < this.lxLB.length; i++) {
        // 因为方法名前缀，都是 _0403_ 所以，gb|sr 必须从6位开始
        if (ffm.indexOf(this.lxLB[i]) == 6) {
            return this.lxLB[i];
        }
    }
}

//从方法名中，提供id.
NW04_jt_zhi.prototype.hqZJ = function (ffm) {
    let _ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    let _qj;
    for (let i = 0; i < this.ffqz.length; i++) {
        _qj = this.ffqz[i];
        if (_ffm.startsWith(_qj)) {//如果方法名以 _0403_z_(gb|sr) 开始
            return ffm.substring(_qj.length + 1);
        }
    }
}


;
///<jscompress sourcefile="NW04_jt_gdt.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_gdt(fq) {
    this.fq = fq;
    //默认节点id
    this.mrJD = fq.mrJD;
    // 鼠标事件-纯方法名。
    this.gdtFFM = /^_0403_gdt_gd$/i
    this.gdtFFMHzj = /^_0403_gdt_gd_[0-9a-z_]+$/i
    //监听【类型列表】
    this.lxLB = ['gdt_gd']
    //方法前缀
    this.ffqz = [
        '_0403_gdt_gd'
    ]
}

NW04_jt_gdt.prototype.tjRW = function (dx) {
    let _jt_id;
    let _mrjd = dx[this.mrJD];
    for (let ffm in dx) {

        //如果方法是 监听 要调用的方法（纯方法。没有配置节点id在里面）
        if (this.gdtFFM.test(ffm)) {
            _jt_id = dx[ffm + 'zj'];//方法监听 节点的id值
            //判断此方法的要监听的 节点
            if (!_jt_id) {//如果不存在这个属性，表示用户没有配置专门的节点id。检测是否配置了默认节点id，如果没有配置，表明这不是监听方法。
                if (!_mrjd) {//没有配置默认节点
                    continue;//下一个方法。这个方法不是监听方法。
                }
                _jt_id = _mrjd;
            }
            //找齐了一个配置。监听节点id、 方法名、对象、方法归属哪种监听；将分析结束，放入到父容器中保存（以监听任务形式）
            this.fq.tjRWdx(_jt_id, ffm, dx, this.hqLX(ffm));//添加【监听作业】。
            continue;
        }
        //如果 方法是由 
        //  /^_0403_gdt_gd_[0-9a-z_]+$/i 组成：
        if (this.gdtFFMHzj.test(ffm)) {
            this.fq.tjRWdx(this.hqZJ(ffm), ffm, dx, this.hqLX(ffm));
        }
    }
}
//从方法名，分析出 本方法要绑定在 哪种事件。 比如：单击、右右......

NW04_jt_gdt.prototype.hqLX = function (ffm) {
    ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    for (let i = 0; i < this.lxLB.length; i++) {
        // 因为方法名前缀，都是 _0403_ 所以，gaibian|shuru 必须从6位开始
        if (ffm.indexOf(this.lxLB[i]) == 6) {
            return this.lxLB[i];
        }
    }
}

//从方法名中，提供id.
NW04_jt_gdt.prototype.hqZJ = function (ffm) {
    let _ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    let _qj;
    for (let i = 0; i < this.ffqz.length; i++) {
        _qj = this.ffqz[i];
        if (_ffm.startsWith(_qj)) {//如果方法名以 _0403_gdt_gd 开始
            return ffm.substring(_qj.length + 1);
        }
    }
}


;
///<jscompress sourcefile="NW04_jt_ck.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_ck(fq) {
    this.fq = fq;
    this.bds = /^_0403_ck_gb$/i
    this.lxLB = ['ck_gb']
    //方法
    this.ffqz = [
        '_0403_ck_gb'
    ]
}

NW04_jt_ck.prototype.tjRW = function (dx) {
    for (let ffm in dx) {
        if (this.bds.test(ffm)) {
            this.fq.tjRWdx(null, ffm, dx, 'ck_gb');
            return;
        }
    }
};
///<jscompress sourcefile="NW04_jt_cm.js" />
// 监听引擎。为用户提供方便、智能的监听 

function NW04_jt_cm(fq) {
    this.fq = fq;
    //默认节点id
    this.mrJD = fq.mrJD;
    // 鼠标事件-纯方法名。
    this.jp = /^_0403_cm_(ks|yd|js){1}$/i
    this.jpHzj = /^_0403_cm_(ks|yd|js)_[0-9a-z_]+$/i
    //监听【类型列表】
    this.lxLB = ['cm_ks', 'cm_yd', 'cm_js']
    //方法前缀
    this.ffqz = [
        '_0403_cm_ks',
        '_0403_cm_yd',
        '_0403_cm_js'
    ]
}

NW04_jt_cm.prototype.tjRW = function (dx) {
    let _jt_id;
    let _mrjd = dx[this.mrJD];
    for (let ffm in dx) {

        //如果方法是 监听 要调用的方法（纯方法。没有配置节点id在里面）
        if (this.jp.test(ffm)) {
            _jt_id = dx[ffm + 'zj'];//方法监听 节点的id值
            //判断此方法的要监听的 节点
            if (!_jt_id) {//如果不存在这个属性，表示用户没有配置专门的节点id。检测是否配置了默认节点id，如果没有配置，表明这不是监听方法。
                if (!_mrjd) {//没有配置默认节点
                    continue;//下一个方法。这个方法不是监听方法。
                }
                _jt_id = _mrjd;
            }
            //找齐了一个配置。监听节点id、 方法名、对象、方法归属哪种监听；将分析结束，放入到父容器中保存（以监听任务形式）
            this.fq.tjRWdx(_jt_id, ffm, dx, this.hqLX(ffm));//添加【监听作业】。
            continue;
        }
        //如果 方法是由 
        // /^_0403_cm_(ks|yd|js)_[0-9a-z_]+$/i 组成：
        if (this.jpHzj.test(ffm)) {
            this.fq.tjRWdx(this.hqZJ(ffm), ffm, dx, this.hqLX(ffm));
        }
    }
}
//从方法名，分析出 本方法要绑定在 哪种事件。 比如：单击、右右......

NW04_jt_cm.prototype.hqLX = function (ffm) {
    ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    for (let i = 0; i < this.lxLB.length; i++) {
        // 因为方法名前缀，都是 _0403_ 所以，['cm_ks', 'cm_yd', 'cm_js']必须从6位开始
        if (ffm.indexOf(this.lxLB[i]) == 6) {
            return this.lxLB[i];
        }
    }
}

//从方法名中，提供id.
NW04_jt_cm.prototype.hqZJ = function (ffm) {
    let _ffm = ffm.toLowerCase();//转成小写，方法比较、查找。
    let _qj;
    for (let i = 0; i < this.ffqz.length; i++) {
        _qj = this.ffqz[i];
        if (_ffm.startsWith(_qj)) {//如果方法名以 _0403_cm_(ks|yd|js) 开始
            return ffm.substring(_qj.length + 1);
        }
    }
}


;
///<jscompress sourcefile="NW04_mb_gj.js" />
function NW04_mb_gj() {

}

// 字符串叠加
NW04_mb_gj.prototype._diejia = function (zhi, zhi1, zhi2, zhi3, zhi4) {
    if (!zhi) {
        zhi = '';
    }
    if (null != zhi1 && zhi1 != '') {
        zhi += zhi1;
    }
    if (null != zhi2 && zhi2 != '') {
        zhi += zhi2;
    }
    if (null != zhi3 && zhi3 != '') {
        zhi += zhi3;
    }
    if (null != zhi4 && zhi4 != '') {
        zhi += zhi4;
    }

    return zhi;
}

/**
 * 移动到一个 变量模板的 开始处
 * 
 *  假设传入字符串为 aaaaaaaaa{{dizhi}}?q=abc
 *   
 * 结果为：
 *   YuanS: (3) ['aaaaaaaaa', 'dizhi', '?q=abc']
 *   YBS: [1] , YBS[1]的值为 1， 即，表示 YuanS[1]的值，是变量名
 * 
 * @param {数字} yb0 开始游标
 * @param {数组} zifuchuan 源字符串
 * @返回  {null|数组} 解释后的 字符串，和变量名。
 */
NW04_mb_gj.prototype.fenxi = function (zifuchuan) {
    if (!zifuchuan || zifuchuan.length == 0) {
        return null;
    }
    let _ShujuS = zifuchuan.split('');//源数组
    //最大的游标
    let zdYB = _ShujuS.length - 1;
    //存放结果
    let jg = {
        yb: 0,
        YuanS: [],//存放 原始数据
        YBS: [], //存放 游标 指定 YuanS 哪个元素是变量名（需要替换掉的）
        ftj: function (zhi) {
            this.YuanS.push(zhi);
            this.yb++;
        },
        ftjBL: function (zhi) {
            if (zhi) {
                this.YuanS.push(zhi);
                this.YBS.push(this.yb);
                this.yb++;
            }
        }
    }

    let _rq = 0;         //p=1 字符串值  ；b=2 变量;

    //p阵营
    let _pZhi = null;       //字符串值
    //b阵营
    let _bZhi = null;       //变量 用于存放变量模板中，变量名  {{变量名}}
    let _bo = -1;           //记录最后一个{的下标

    let dzf = null;       //单字符;
    for (let i = 0; i < _ShujuS.length; i++) {
        dzf = _ShujuS[i];
        //这次循环，是最后一次循环，不可能组成 }} 变量模板的 结束符。
        //因为，每次碰到 符号{   或   符号}，总是取 i+1 个字符判断，是开头，还是结束。
        if (i + 1 > zdYB) {
            _pZhi = this._diejia(_pZhi, (_rq == 2 ? '{{' : ''), _bZhi, dzf);
            if (_pZhi != null && _pZhi != '') {
                jg.ftj(_pZhi);
            }
            break;//结束循环
        }

        switch (dzf) {
            case '{'://表示开始
                if (_rq == 1) {//当前是 普通阵营 在接收值
                    //2、判断下一个字符，是不是{,如果是{ , 组成新的开始标识。
                    dzf = _ShujuS[++i];
                    if (dzf == '{') {//表示 连续的 {{ ,暂时定为 变量模板的开始。
                        _bo = i;        //记录最后坐标
                        _rq = 2         //交给 变量阵营 接收值。
                    } else {//无法组成新的开始符。
                        _pZhi = this._diejia(_pZhi, '{', dzf);//依然是 普通阵营 在接收值
                    }
                } else if (_rq == 2) { //当前是 变量阵营 在接收值
                    //首先判断，是不是连续的
                    if (_bo == (i - 1)) {//如果 连续性的 比如：{{{{
                        _pZhi = this._diejia(_pZhi, '{');//推送一个到p阵营。
                        _bo = i;//记录最新的{位置
                    } else {//如果不是连续性的 {{{
                        //2、判断下一个字符，是不是{,如果是{ , 组成新的开始标识。
                        dzf = _ShujuS[++i];
                        if (dzf == '{') {//表示 连续的 {{ ,暂时定为 变量模板的开始。
                            //1.1、转移 之前_bZhi的旧数据
                            _pZhi = this._diejia(_pZhi, '{{', _bZhi);
                            //1.2、清空
                            _bZhi = null;
                            _bo = i;//记录最后坐标
                            // _rq=2//不变，还是当前的 阵营在接收值
                        } else {//无法组成新的开始符。
                            //1.1、转移 变量阵营的数据 到 普通阵营。（因为变量阵营 无法组成 完整的变量）
                            _pZhi = this._diejia(_pZhi, '{{', _bZhi, '{', dzf);
                            //1.2、清空
                            _bZhi = null;
                            _rq = 1;//交给 普通阵营接收值。
                        }
                    }
                } else {//表示没指明 是哪个 阵营在 接收值
                    dzf = _ShujuS[++i]; //2、判断下一个字符,如果是{ , 组成新的开始标识。
                    if (dzf == '{') {   //表示 连续的 {{ ,暂时定为 变量模板的开始。
                        _rq = 2;        //表示 接下来，是变量阵营 接收值
                        _bo = i;        //记录  变量阵营 接管时间点（数组下标）
                    } else {
                        _rq = 1;        //无法组成 变量开始 符号。定为 普通阵营。
                        _pZhi = this._diejia(_pZhi, '{', dzf);//推送一个到  普通阵营。
                    }
                }
                continue;
            case ' ':
                if (_rq == 1) {
                    _pZhi = this._diejia(_pZhi, ' ');
                }
                continue;
            case '}':
                if (_rq == 1) { //如果是普通阵营在接收值，依然当普通值接收
                    _pZhi = this._diejia(_pZhi, '}');

                } else if (_rq == 2) {//如果是 变量阵营 在接收值， 那么，检测下一个字符，是不是 }
                    dzf = _ShujuS[++i];//下一个字符串
                    if (dzf == '}') {//如果也是} ，那么，组成了 }} 变量结束符。
                        if (null != _pZhi) {
                            jg.ftj(_pZhi)
                        }
                        jg.ftjBL(_bZhi);//变量名。
                        //重新定位
                        _rq = 0;//未知类型。要看下一个字符是什么
                        _bo = -1;
                        _pZhi = null;
                        _bZhi = null;
                    } else {
                        //将 变量阵营 转移到普通阵营。因为，它们无法组成 一个完整的变量
                        _pZhi = this._diejia(_pZhi, '{{', _bZhi, '}', dzf);//把开始符，变量缓存值，},及下个字符dzf，转移到普通阵营

                        //重新定位
                        _rq = 0;//未知类型。要看下一个字符是什么
                        _bo = -1;
                        _bZhi = null;
                    }
                } else {
                    _rq = 1;
                    _pZhi = this._diejia(_pZhi, '}');//表示，文本以 }开头。
                }
                continue;
            default:
                if (_rq == 1) { //如果是普通阵营在接收值，依然当普通值接收
                    _pZhi = this._diejia(_pZhi, dzf);
                } else if (_rq == 2) {//如果是 变量阵营 在接收值
                    _bZhi = this._diejia(_bZhi, dzf);
                } else {
                    _rq = 1;
                    _pZhi = this._diejia(_pZhi, dzf);//表示，文本
                }
        }
    }
    return jg;
}
;
///<jscompress sourcefile="NW04_mb_nr.js" />
function NW04_mb_nr(fq) {
    this.nw = fq.fq.fq;//nw对象
    this.gj = fq.gj;
}

/**
 * 翻译 模板（替换模板 占位符）
 * @参数 {文本|对象} JieDianHuoZJ 节点对象|节点id|NW封装节点对象
 * @参数 {对象} DX 数据对象
 */
NW04_mb_nr.prototype.fy = function (JieDianHuoZJ, DX) {

    let _$Jiedian = this.nw.cj(JieDianHuoZJ);
    let _WBS = _$Jiedian.jd.hqNRjdM(true);
    
    let _wbMB_S;
    for (let i = 0; i < _WBS.length; i++) {
        if (_WBS[i]) {
            _wbMB_S = this.gj.fenxi(_WBS[i].nodeValue)
            this._ngj_fy(_WBS[i], _wbMB_S, DX);
        }
    }
}

/**
 * 翻译 模板（替换模板 占位符）
 * @参数 {文本|对象} WBS   节点对象|节点id|NW封装节点对象
 * @参数 {对象} DX         数据对象
 */
NW04_mb_nr.prototype.fy_tgNRm = function (WBS, DX) {
    if (null == WBS || WBS.length == 0) {
        return;
    }
    let _wbMB_S;
    for (let i = 0; i < WBS.length; i++) {
        if (WBS[i]) {
            _wbMB_S = this.gj.fenxi(WBS[i].nodeValue)
            this._ngj_fy(WBS[i], _wbMB_S, DX);
        }
    }
}

/**
 * 取得翻译后的模板
 * @参数 {对象} WBJiedian 文本节点 对象
 * @返回 {数组|null} 执行 翻译后的 模板组
 */
NW04_mb_nr.prototype.hqMB = function (WBJiedian) {
    return this.gj.fenxi(typeof WBJiedian == 'string' ? WBJiedian : WBJiedian.nodeValue)
}

/**
 * 执行一个文本节点 的模板 翻译 ffyDanMB（ 翻译单模板 ）
 * @param {对象} WBJiedian 文本对象（1个）
 * @param {模板} MB 文本相关的模板
 * @param {对象} DX 动态参数（参数值用于替换 模板中的变量；参数名与模板中的变量名一 一 对应）
 */
NW04_mb_nr.prototype._ngj_fy = function (WBJiedian, MB, DX) {
    if (MB) {
        let _blMingHuoZhi;    //变量名，或 文本值
        let _wb1 = '';

        for (let i = 0; i < MB.YuanS.length; i++) {
            _blMingHuoZhi = MB.YuanS[i];

            if (MB.YBS.indexOf(i) != -1) {
                //表示此i个格子( MB.YuanS[i] )，放的是  变量
                if (DX && DX[_blMingHuoZhi] != null) {
                    _blMingHuoZhi = DX[_blMingHuoZhi];
                } else {
                    _blMingHuoZhi = ''
                }
                _wb1 += _blMingHuoZhi;
            } else {
                //表示此i个格子( MB.YuanS[i] )，放的是  文本值
                _wb1 += MB.YuanS[i];
            }
        }
        WBJiedian.nodeValue = _wb1;
    }
};
///<jscompress sourcefile="NW04_mb_sx.js" />
function NW04_mb_sx(fq) {
    this.nw = fq.fq.fq;//nw对象
    this.gj = fq.gj;
}

/**
 * 翻译 模板（替换模板 占位符）
 * @参数 {文本|对象} JieDianHuoZJ 节点对象|节点id|NW封装节点对象
 * @参数 {对象} DX 数据对象
 */
NW04_mb_sx.prototype.fy = function (JieDianHuoZJ, DX) {

    let _$Jiedian = this.nw.cj(JieDianHuoZJ);
    let _SXS = _$Jiedian.jd.hqMBsxM();

    let _mb_S;
    for (let i = 0; i < _SXS.length; i++) {
        if (_SXS[i]) {
            // 分析出【模板】
            _mb_S = this.gj.fenxi(_SXS[i].value)
            // 将模板中的数据替换成 DX指定的值
            this._ngj_fy(_SXS[i], _mb_S, DX);
        }
    }
}

/**
 * 翻译 模板（替换模板 占位符）
 * @参数 {文本|对象} WBS   节点对象|节点id|NW封装节点对象
 * @参数 {对象} DX         数据对象
 */
NW04_mb_sx.prototype.fy_tgSXm = function (SXS, DX) {
    if (null == SXS || SXS.length == 0) {
        return;
    }
    let _mb_S;
    for (let i = 0; i < SXS.length; i++) {
        if (SXS[i]) {
            _mb_S = this.gj.fenxi(SXS[i].value)
            this._ngj_fy(SXS[i], _mb_S, DX);
        }
    }
}

/**
 * 取得翻译后的模板
 * @参数 {对象} ShuxingJiedian 文本节点 对象
 * @返回 {数组|null} 执行 翻译后的 模板组
 */
NW04_mb_sx.prototype.hqMB = function (ShuxingJiedian) {
    return this.gj.fenxi(typeof ShuxingJiedian == 'string' ? ShuxingJiedian : ShuxingJiedian.value)
}

/**
 * 执行一个文本节点 的模板 翻译 ffyDanMB（ 翻译单模板 ）
 * @param {对象} SXJiedian 文本对象（1个）
 * @param {模板} MB 文本相关的模板
 * @param {对象} DX 动态参数（参数值用于替换 模板中的变量；参数名与模板中的变量名一 一 对应）
 */
NW04_mb_sx.prototype._ngj_fy = function (SXJiedian, MB, DX) {
    if (MB) {
        let _blMingHuoZhi;    //变量名，或 文本值
        let _zhi = '';

        for (let i = 0; i < MB.YuanS.length; i++) {
            _blMingHuoZhi = MB.YuanS[i];

            if (MB.YBS.indexOf(i) != -1) {
                //表示此i个格子( MB.YuanS[i] )，放的是  变量
                if (DX && DX[_blMingHuoZhi] != null) {
                    _blMingHuoZhi = DX[_blMingHuoZhi];
                } else {
                    _blMingHuoZhi = ''
                }
                _zhi += _blMingHuoZhi;
            } else {
                //表示此i个格子( MB.YuanS[i] )，放的是  文本值
                _zhi += MB.YuanS[i];
            }
        }
        SXJiedian.value = _zhi;
    }
};
///<jscompress sourcefile="NW04_mb.js" />
function NW04_mb(fq) {
    // this.nw = fq.fq;//nw对象
    this.fq = fq;//上级对象
    this.gj = new NW04_mb_gj();
    this.sx = new NW04_mb_sx(this);
    this.nr = new NW04_mb_nr(this);
}

NW04_mb.prototype.fy = function (zj, mbZhi) {
    this.sx.fy(zj, mbZhi);
    this.nr.fy(zj, mbZhi);
}

NW04_mb.prototype.hqMB_sx = function (ShuxingJiedian) {
    return this.sx.hqMB(ShuxingJiedian)
}

NW04_mb.prototype.hqMB_nr = function (ShuxingJiedian) {
    return this.nr.hqMB(ShuxingJiedian)
};
///<jscompress sourcefile="NW04.js" />
function NW04(fq) {
    this.fq = fq;//nw
    this.rw = new NW04_rw(this);//任务管理 中心
    this.jt = new NW04_jt(this);//事件管理 中心
    this.mb = new NW04_mb(this);//模板管理 中心
    this.zdy = new NW04_zdy(this);
}

/**
 * 分析缓存的对象，如果有配置了延时任务的，加入延时任务。
 * @param {*} dxSZ 
 */
NW04.prototype.tjRW = function (dxSZ) {
    for (let i = 0; i < dxSZ.length; i++) {
        this.rw.tjYanshiRW(dxSZ[i]);//如果存在任务，会自动加入。
        this.jt.jt(dxSZ[i])         //如果存在监听，加入监听
    }
}

/**
 * 启动任务
 */
NW04.prototype.qdRW = function () {
    this.rw.qd()
};
///<jscompress sourcefile="NW05_bj.js" />
//窗口布局管理
function NW05_bj(fq) {
    this.fq = fq;//nw
    this.nw = fq.fq;
    this.nys_wz = { wz: 'absolute' };
    this.zzbds_shuzi = /^[0-9.]+$/i
}

//对body进行布局.
NW05_bj.prototype.stBJ = function () {
    for (let i = 0; i < 5; i++) {
        this.buju(this.nw.st);
    }
}

/**
 * 对jd内进行布局.调整儿子 
 * @param {对象} nwJD nw封装的节点对象
 */
NW05_bj.prototype.buju = function (nwJD) {
    let _ErziM = nwJD.Jiedian.children;
    let _NWerziM = [];
    let _nwErzi;

    for (let i = 0; i < _ErziM.length; i++) {

        // this.nw.yq.zdy.zx1(_ErziM[i])
        if (_ErziM[i].getAttributeNode('hlbj')) {
            continue;
        }
        switch (_ErziM[i].nodeName) {
            case 'PZ':
                continue;
            case 'DIV':
            case 'IFRAME':
            case 'BUJU':
            case 'BJ':
            case 'NR':
                _nwErzi = this.nw.cj(_ErziM[i]);
                //隐藏的,跳过
                if (_nwErzi.ys.hqNYS('display') == 'none') {
                    continue;
                }
                _NWerziM.push(_nwErzi);
        }
    }

    for (let i = 0; i < _NWerziM.length; i++) {
        _nwErzi = _NWerziM[i];
        this._ngj_tzGK(nwJD, _nwErzi, _NWerziM)

        //针对iframe 和 nr节点，不再进行他们的儿子定位检测
        if (_ErziM[i].nodeName == 'IFRAME' || _ErziM[i].nodeName == 'NR') {
            continue;
        }
        this.buju(_nwErzi);
    }
    if (nwJD)
        this._ngj_ylj_h(_NWerziM)

}

NW05_bj.prototype._ngj_tzGK = function (nwJD, _nwErzi, _ErziM, dw) {
    let fqys = nwJD.ys;
    let erys = _nwErzi.ys;
    let _PZ = {}
    // 表示从父长宽中计算得到=''  
    // 表示写死='xxx'  比如 100px
    // 表示没有=null
    // 表示自动='zd'
    let _zhi_g = this._ngj_hqGKpz(_nwErzi, 'g');
    let _zhi_k = this._ngj_hqGKpz(_nwErzi, 'k');
    if (_zhi_g == '') {
        _PZ.g = this.hqG(fqys, erys, dw);
    } else if (_zhi_g == 'zd') {
        //我的高=父-计算要减去的同列的、写死的高-其他的
        //同列的，固定的【高】
        let _wo_l = _nwErzi.jd.hqSXzhi('l');
        let jian = 0;//要减去的高
        if (_wo_l) {
            // console.log(_nwErzi.Jiedian)
            jian = this._ngj_hqGKzhi_jian(_ErziM, 'l', _wo_l, 'g');//要减去的高。同列兄弟节点中，那些写死的高
            // console.log('要减去的高：'+jian)
        }
        _PZ.g = this.hqG2(fqys, erys, jian, dw)
    } else if (_zhi_g != null) {//直接写死的
        _PZ.g = this.zzbds_shuzi.test(_zhi_g) ? _zhi_g + this.hqDW(erys.hqG_dw(), dw) : _zhi_g;
    }

    if (_zhi_k == '') {
        _PZ.k = this.hqK(fqys, erys, dw);
    } else if (_zhi_k == 'zd') {
        //我的高=父-计算要减去的同列的、写死的高-其他的
        //同列的，固定的【高】
        let _wo_l = _nwErzi.jd.hqSXzhi('h');
        let jian = 0;//要减去的高
        if (_wo_l) {
            jian = this._ngj_hqGKzhi_jian(_ErziM, 'h', _wo_l, 'k');//要减去的高。同列兄弟节点中，那些写死的高
        }
        _PZ.k = this.hqK2(fqys, erys, jian, dw)
    } else if (_zhi_k != null) {//直接写死的
        _PZ.k =
            this.zzbds_shuzi.test(_zhi_k) ? _zhi_k + this.hqDW(erys.hqK_dw(), dw) : _zhi_k;
        // _zhi_k + this.hqDW(erys.hqK_dw(), dw);
    }
    erys.xgNYS(_PZ);
}
//同行的,右连接一起.
NW05_bj.prototype._ngj_ylj_h = function (_ErziM) {
    let hSZ = []//标注了行的节点
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i].jd.hqSXzhi('h')) {
            hSZ.push(_ErziM[i])
        }
    }
    let let1 = null;
    let shangyihangKaishi = null;//上一行的开始
    let dyc = true;//第1次
    // [a=1,b=2,c=1 ]
    for (let i = 0; i < hSZ.length; i++) {

        // [a=1,b=2,c=1 ]
        let1 = hSZ[i];  //比如,第2个节点
        if (!let1) {
            continue;
        }
        this._ngj_wz(let1)
        //在兄弟节点中,第1行的第1个,锁定为0,0
        if (dyc) {
            let1.ys.xy_zsj(0, 0)
            dyc = false;
        }

        if (shangyihangKaishi) {
            shangyihangKaishi.ys.xy_xlj(let1)
        }
        shangyihangKaishi = let1;

        for (let j = 0; j < hSZ.length; j++) {
            if (j == i || !hSZ[j]) {
                continue;//自己不能与自己连接
            }
            if (let1.jd.hqSXzhi('h') == hSZ[j].jd.hqSXzhi('h')) {
                this._ngj_wz(hSZ[j])
                let1.ys.xy_ylj(hSZ[j]);
                let1 = hSZ[j];
                hSZ[j] = null;
            }
        }
    }
}
// 如果没有指定 定位模式,统一设计绝对定位
NW05_bj.prototype._ngj_wz = function (nwDX) {
    if (!nwDX.ys.hqNYS('position')) {
        nwDX.ys.xgNYS(this.nys_wz)
    }
}

//要减去的高宽值
//从兄弟节点中，找到其他sxMing属性的节点。然后，计算 g或k的写死的宽，或高。
NW05_bj.prototype._ngj_hqGKzhi_jian = function (_ErziM, sxMing, sxZhi, gk) {
    let _nwErzi;
    let leiji = 0;//累计
    let linshi;//临时。
    let woys;
    for (let i = 0; i < _ErziM.length; i++) {
        _nwErzi = _ErziM[i];
        woys = _nwErzi.ys;
        // if (_nwErzi.ys.pdYC()) {
        //     continue;
        // }
        if (_nwErzi.jd.hqSXzhi(sxMing) == sxZhi) {//表示同个行或列
            linshi = this._ngj_hqGKpz(_nwErzi, gk);
            // console.log('gk值=' + linshi)
            //如果是写死长度的（不是自动分析的，不是基于父计算出来的，存在gk配置的）
            if (linshi != 'zd' && linshi != '' && linshi != null) {
                leiji += parseFloat(linshi);
                if (gk == 'g') {
                    leiji += woys.hqWBJ_s() + woys.hqWBJ_x() + woys.hqBK_s() + woys.hqBK_x()
                } else {
                    leiji += woys.hqWBJ_z() + woys.hqWBJ_y() + woys.hqBK_z() + woys.hqBK_y()
                }
            }
        }
    }
    return leiji;
}

// 从 属性 gk 或 g 或 k 中，取得我们要的 g或k值
// 值一般为： 
// 表示从父长宽中计算得到=''  
// 表示写死='xxx'  比如 100px
// 表示没有=null
// 表示自动='zd'
NW05_bj.prototype._ngj_hqGKpz = function (nwJD, gk) {
    let _zhi;
    if ((_zhi = nwJD.jd.hqSXzhi('gk')) != null) {
        return ''//表示 100父亲宽或高
    }
    if ((_zhi = nwJD.jd.hqSXzhi(gk)) != null) {
        return _zhi;
    }
    return null;
}


NW05_bj.prototype.hqG = function (fqys, erys, dw) {
    dw = this.hqDW(erys.hqG_dw(), dw);
    return fqys.hqG() - erys.hqWBJ_s() - erys.hqWBJ_x() - erys.hqBK_s() - erys.hqBK_x() - erys.hqNBJ_s() - erys.hqNBJ_x() + dw;
}

NW05_bj.prototype.hqG2 = function (fqys, erys, jian, dw) {
    dw = this.hqDW(erys.hqG_dw(), dw);
    return fqys.hqG() - jian - erys.hqWBJ_s() - erys.hqWBJ_x() - erys.hqBK_s() - erys.hqBK_x() - erys.hqNBJ_s() - erys.hqNBJ_x() + dw;
}

NW05_bj.prototype.hqK = function (fqys, erys, dw) {
    dw = this.hqDW(erys.hqK_dw(), dw);
    return fqys.hqK() - erys.hqWBJ_z() - erys.hqWBJ_y() - erys.hqBK_z() - erys.hqBK_y() - erys.hqNBJ_z() - erys.hqNBJ_y() + dw;
}


NW05_bj.prototype.hqK2 = function (fqys, erys, jian, dw) {
    dw = this.hqDW(erys.hqK_dw(), dw);
    return fqys.hqK() - jian - erys.hqWBJ_z() - erys.hqWBJ_y() - erys.hqBK_z() - erys.hqBK_y() - erys.hqNBJ_z() - erys.hqNBJ_y() + dw;
}


NW05_bj.prototype.hqDW = function (_zzDW, dw) {
    if (dw) {
        return dw;
    } else {
        return _zzDW ? _zzDW : 'px';
    }
};
///<jscompress sourcefile="NW05_dw.js" />
//窗口布局管理
function NW05_dw(fq) {
    this.fq = fq;//nw
    this.nw = fq.fq;
}

//对body进行布局.
NW05_dw.prototype.stDW = function () {
    this.dw(this.nw.st);
}

/**
 * 对jd内进行布局.调整儿子 
 * @param {对象} nwJD nw封装的节点对象
 */
NW05_dw.prototype.dw = function (nwJD) {

    if (nwJD.Jiedian.getAttributeNode('xddw') || nwJD.Jiedian.getAttributeNode('gddw')) {
        this.dw1(nwJD);
    }

    let _ErziM = nwJD.Jiedian.children;
    let _nwErzi;
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i].getAttributeNode('hlbj')) {
            continue;
        }
        switch (_ErziM[i].nodeName) {
            case 'PZ':
                continue;
            case 'DIV':
            case 'IFRAME':
            case 'BUJU':
            case 'BJ':
            case 'NR':
                _nwErzi = this.nw.cj(_ErziM[i]);

                // if (_ErziM[i].getAttributeNode('xddw') || _ErziM[i].getAttributeNode('gddw')) {
                //     this.dw1(_nwErzi);
                // }
                //针对iframe 和 nr节点，不再进行他们的儿子定位检测
                // if (_ErziM[i].nodeName == 'IFRAME' || _ErziM[i].nodeName == 'NR') {
                //     continue;
                // }
                this.dw(_nwErzi);//检测他的儿子.
        }

    }
}

//定位
NW05_dw.prototype.dw1 = function (nwDX) {
    let pz = this._ngj_hqPZ(nwDX);
    if (pz && pz.fw) {
        switch (pz.fw) {
            case 'zsj': pz.lx
                ? nwDX.ys.xy_zsj2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_zsj(pz.x, pz.y, pz.dw); break;
            case 'sz': pz.lx
                ? nwDX.ys.xy_sz2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_sz(pz.x, pz.y, pz.dw); break;
            case 'ysj': pz.lx
                ? nwDX.ys.xy_ysj2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_ysj(pz.x, pz.y, pz.dw); break;

            case 'zz': pz.lx
                ? nwDX.ys.xy_zz2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_zz(pz.x, pz.y, pz.dw); break;
            case 'yz': pz.lx
                ? nwDX.ys.xy_yz2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_yz(pz.x, pz.y, pz.dw); break;

            case 'zxj': pz.lx
                ? nwDX.ys.xy_zxj2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_zxj(pz.x, pz.y, pz.dw); break;
            case 'xz': pz.lx
                ? nwDX.ys.xy_xz2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_xz(pz.x, pz.y, pz.dw); break;
            case 'yxj': pz.lx
                ? nwDX.ys.xy_yxj2(pz.x, pz.y, pz.dw)
                : nwDX.ys.xy_yxj(pz.x, pz.y, pz.dw); break;

            case 'zzj':
                pz.lx
                    ? nwDX.ys.xy_zzj2(pz.x, pz.y, pz.dw)
                    : nwDX.ys.xy_zzj(pz.x, pz.y, pz.dw); break;
        }
    }

}

NW05_dw.prototype._ngj_hqPZ = function (nwJD) {
    let lx = 0;
    let _zhi = nwJD.jd.hqSXzhi('xddw');//相对定位
    if (!_zhi) {
        _zhi = nwJD.jd.hqSXzhi('gddw');//相对定位
        lx = 2;
    }
    if (_zhi) {
        //方位,x偏量,y偏量,单位
        let jg = { fw: null, x: 0, y: 0, dw: null, lx: lx };

        if (_zhi.indexOf(',')) {
            _zhi = _zhi.split(',');
            switch (_zhi.length) {
                case 4:
                    jg.dw = _zhi[3] ? _zhi[3] : 'px'
                case 3:
                    jg.y = _zhi[2] ? parseFloat(_zhi[2]) : 0
                case 2:
                    jg.x = _zhi[1] ? parseFloat(_zhi[1]) : 0
                case 1:
                    jg.fw = _zhi[0];
            }
        } else {
            jg.fw = _zhi
        }
        return jg;
    }
    return null;
};
///<jscompress sourcefile="NW05_tcc_cs.js" />
// 用来缓存 对话框数据。
function NW05_tcc_cs(bd, fq) {
    this.fq = fq;                   //父亲容器。即，对话框是 fq的儿子

    this.geli = false;              //隔离。 真值=表示内容区嵌入一个iframe; 假值=不嵌入iframe

    //本地有关配置
    this.juese = bd;//表示页面里面，哪个节点（id）是本弹出层【配置】。
    this.juese_tb = 'tb';
    this.juese_st = 'st';
    this.juese_jb = 'jb';

    //远程（ajax）有关配置 通过方向地址，取得数据。
    this.yc_dizhi = null;    //当 this.geli 为真值时，此地址将被用于iframe src中。
    this.yc_wffs = 'get';    //请求-访问方式
    this.yc_cs = null;      //对象方式 比如：{参数1:1213,参数2:222}

    this.yc_sjgs = 'json';  //请求到的【数据格式】
    this.yc_nr_tb = 'tb';   //远程请示的数据，如果是json格式，通过 【 json对象.tb 】得取 标题数据
    this.yc_nr_st = 'st';   //远程请示的数据，如果是json格式，通过 【 json对象.st 】得取 标题数据
    this.yc_nr_jb = 'jb';   //远程请示的数据，如果是json格式，通过 【 json对象.jb 】得取 标题数据

    //当展开 遮挡层时（与父同尺寸），wz表示 内容层的位置
    //当没有展开遮挡(与内容层同尺寸)，wz表示 遮挡层的位置 
    this.wz = 'zzj';                 //位置：zzj表示正中间
    // 默认的高、宽。
    // 1）当展开遮挡层时，默认内容层的尺寸
    // 2）没展示遮挡层时，默认遮挡层的尺寸。而内容层则为 自动与父（遮挡层）同尺寸。
    this.g = '500px';
    this.k = '350px';


    this.zdh = 1;//最大化： 真值=最大化；假值=指定高宽。
    //启用弹出层时，就就隐藏。默认不隐藏。
    this.qd_yc = false;

    //部件
    this.an_gb = 1;     //真值=显示【按钮-关闭】，假值=隐藏【按钮-关闭】
    this.an_zdh = 1;    //真值=显示【按钮-最大化】，假值=隐藏【按钮-最大化】

    //遮挡层
    this.zdc = 1;                               //用户的配置。 遮挡层： 真值=启用遮挡层；假值=与内容层 同尺寸
    this.zdc_dw = 'gddw';                       //定位：固定定位 gddw； 相对定位 xddw
    this.zdc_bjys = 'rgb(255, 244, 244)'        //遮挡层颜色
    this.zdc_sj = 'tcc_gb';                     //点击遮挡层时，会发生什么事件

    // 等待层
    this.ddc_bjys = '#FFCCFF'
    this.ddc_nr = "<div xddw='zzj'>正在加载...</div>"

    //头部
    this.tb_g = '35px';                     //默认高
    this.tb_bjys = 'rgb(227, 189, 245)'     //默认背景颜色
    this.tb_nr = '';     //内容
    this.tb_pdJZ = 0;    //判断居中。真值=居中；假值=默认（不理）
    this.tb_xs = 1;     //显示。 真值=显示；假值=隐藏
    this.tb_djs = 0;//是否在头部显示倒计时。默认否

    //身体
    this.st_bjys = 'rgb(243, 217, 255)';
    this.st_nr = ''//内容
    this.st_yq = false;//开启内容的引擎。 true=对内容里面的节点，进行布局、定位；false=不动内容里面的东西。

    //脚部
    this.jb_g = '35px';
    this.jb_bjys = 'rgb(220, 159, 248)';
    this.jb_nr = '';     //内容
    this.jb_xs = 1;     //显示。 真值=显示；假值=隐藏

    //事件
    //关闭、最大化.........等等事件触发后，都会调用这个函数（如果存在）。并传入 弹出层对象。
    //用户的方法返回 true时，会继续执行事件。返回false时，会停止执行事件。
    //如果用户需要到远程服务器拿资源后，才可以关闭容器，可以先返回false，阻止窗口关闭。等自己拿到服务器资源后，再自行调用对象，手动关闭。
    this.sj = null;

    //请求网址时，附上随机参数
    this.sjcs_ming = '____d'
    this.sjcs = true;
}

//__对外部约定的方法名。以两个下划线开头
NW05_tcc_cs.prototype.__hqCSlx = function (sxMing) {
    switch (sxMing) {
        case 'qd_yc':
        case 'geli':        //隔离。 真值=表示内容区嵌入一个iframe; 假值=不嵌入iframe
        case 'zdh':         //最大化： 真值=最大化；假值=指定高宽。
        case 'an_gb':       //真值=显示【按钮-关闭】，假值=隐藏【按钮-关闭】
        case 'an_zdh':      //真值=显示【按钮-最大化】，假值=隐藏【按钮-最大化】
        case 'zdc':         //用户的配置。 遮挡层： 真值=启用遮挡层；假值=与内容层 同尺寸
        case 'tb_pdJZ':     //判断居中。真值=居中；假值=默认（不理）
        case 'tb_xs':       //显示。 真值=显示；假值=隐藏
        case 'st_yq':       //开启内容的引擎。 true=对内容里面的节点，进行布局、定位；false=不动内容里面的东西。
        case 'jb_xs':       //显示。 真值=显示；假值=隐藏
        case 'sjcs':        //请求网址时，附上随机参数 。true=启用随机参数。参数名通过 sjcs_ming指定。
            return 'boolean';

        case 'juese':
        case 'juese_tb':
        case 'juese_st':
        case 'juese_jb':
        //远程（ajax）有关配置 通过方向地址，取得数据。
        case 'yc_dizhi':     //当 this.geli 为真值时，此地址将被用于iframe src中。
        case 'yc_wffs':    //请求-访问方式
        case 'yc_sjgs':  //请求到的【数据格式】
        case 'yc_nr_tb':   //远程请示的数据，如果是json格式，通过 【 json对象.tb 】得取 标题数据
        case 'yc_nr_st':   //远程请示的数据，如果是json格式，通过 【 json对象.st 】得取 标题数据
        case 'yc_nr_jb':   //远程请示的数据，如果是json格式，通过 【 json对象.jb 】得取 标题数据
        case 'wz':               //位置：zzj表示正中间
        case 'g':
        case 'k':
        case 'zdc_dw':                      //定位：固定定位 gddw； 相对定位 xddw
        case 'zdc_bjys':                    //遮挡层颜色
        case 'zdc_sj':                      //点击遮挡层时，会发生什么事件
        // 等待层
        case 'ddc_bjys':
        case 'ddc_nr':
        //头部
        case 'tb_g':                    //默认高
        case 'tb_bjys':     //默认背景颜色
        case 'tb_nr':     //内容
        //身体
        case 'st_bjys':
        case 'st_nr':
        //脚部
        case 'jb_g':
        case 'jb_bjys':
        case 'jb_nr':     //内容
        //随机参数
        case 'sjcs_ming': //请求网址时，附上随机参数。 true=启用随机参数。参数名通过 sjcs_ming指定。
            return 'string';
        //事件
        case 'sj':
            return 'function';

        case 'yc_cs':      //对象方式 比如：{参数1:1213,参数2:222}
            return 'object';
    }
}

NW05_tcc_cs.prototype.qd0 = function () {
    this._zb_zhi();
    this._zb_nwJD();
    if (this.sj && typeof this.sj == 'string') {
        try {
            this.sj = eval(this.sj);//取nw_jx空间地址
        } catch (e) {
            console.error('你在【弹出层-参数】对象里面，配置了不存在的函数名：' + this.sj)
            this.sj = null;
        }
    }
}

NW05_tcc_cs.prototype._zb_zhi = function () {
    this.g = this._ngj_gshGK(this.g)
    this.k = this._ngj_gshGK(this.k)
    this.tb_g = this._ngj_gshGK(this.tb_g)
    this.jb_g = this._ngj_gshGK(this.jb_g)
}

/**
 * 如果值为数字，自动附加px单位；
 * 如果值为假值，自动附上【默认值】
 * 
 * @param {文本|数字} zhi 值
 * @param {未知} mrZhi 默认值
 */
NW05_tcc_cs.prototype._ngj_gshGK = function (zhi) {
    if (typeof zhi == 'number') {
        return zhi + 'px'
    } else {
        return zhi
    }
}

//1、准备阶段-父容器
NW05_tcc_cs.prototype._zb_nwJD = function () {
    if (!this.fq) {//没有指定父容器。默认是 body容器
        this.fq = nw.st;
    }
    else if (typeof this.fq == 'string' || !this.fq.Jiedian) {
        this.fq = nw.cj(this.fq)
    }

    if (this.fq != nw.st) {
        this.zdc_dw = 'xddw'//相对定位
    }
}
;
///<jscompress sourcefile="NW05_tcc_gt.js" />
// 用来缓存 对话框数据。
function NW05_tcc_gt(fq, cs) {
    this.nw = fq.nw;
    this.hc = fq.hc;           //缓存池
    this.sj = fq.sj;

    this.zdcRQ = null;           //对话框 容器(遮挡层)
    this.nrcRQ = null;           //容器里面的 内容层
    this.tbJD = null;
    this.stJD = null;
    this.jbJD = null;
    this.gbAN = null;            //关闭按钮
    this.zdhAN = null;           //最大化按钮
    this.ddc = null;
    this.cs = cs;// new NW05_tcc_cs()

    // this.sfz = 0;//身份证。创建对象时，外部写唯一的（对于弹出层）
    // this.i = 0;


    this._bj = this.nw.ck.bj;
    this._dw = this.nw.ck.dw;
    this._zt_bg = 1;//记录关闭状态
}

NW05_tcc_gt.prototype.djs_bt = function () {
    wo = this;
    setTimeout(function () {
        wo.tb(NWHS_hqJKshijian())
        if (wo._zt_bg) {
            setTimeout(arguments.callee, 1000);
        }
    }, 1000);
}

NW05_tcc_gt.prototype.qd0 = function () {
    this._cjZDC();
    this._cjNRC();
    this._cjNRC_tb();
    this._cjNRC_st();
    this._cjNRC_jb();
    this._cjNRC_gbAN()
    this._cjNRC_zdhAN();

    this.xsDDC();
    this.jiazaiNR();
    if (this.cs.tb_djs) {
        this.djs_bt()
    }
    //开始分析代码
    this.nw.yq.zdy.zx(this.nrcRQ.Jiedian)

    if (!this.cs.tb_xs) {
        this.tbJD.ys.xs();
    }
    if (!this.cs.jb_xs) {
        this.jbJD.ys.xs();
    }
    this._ngj_bj_dw();
    this.sj.zcSJ(this.zdcRQ.Jiedian);//重新注册事件
    if (this.cs.qd_yc) {
        this.zdcRQ.ys.xs(0);
    }
}
// ======================↓↓↓=========================
//1、创建遮挡层
NW05_tcc_gt.prototype._cjZDC = function () {
    //创建属性
    let _SX = { rq: 'tcc', style: 'background-color:' + this.cs.zdc_bjys + ' ; z-index: 999;position: absolute;overflow:hidden' }
    _SX[this.cs.zdc_dw] = this.cs.wz;
    if (this.cs.zdc_sj) {
        _SX.ajlb = this.cs.zdc_sj
    }
    if (this.cs.zdc || this.cs.zdh) {   //最大化，或启用遮挡层时
        _SX.g = '';//与父同高宽
        _SX.k = '';//与父同高宽
    } else {
        _SX.g = this.cs.g
        _SX.k = this.cs.k
    }
    this.zdcRQ = this.nw.cj2(this.cs.fq.jd.cjEZ('buju', _SX));
}

//2、在遮挡层 内，创建一个【内容层】容器
NW05_tcc_gt.prototype._cjNRC = function () {
    let _SX = { style: 'overflow:hidden' }
    //如果遮挡层与父同尺寸（100%）。那么，用户配置的位置，直接调整 内容层
    _SX.xddw = this.cs.zdc ? this.cs.wz : "zzj"
    //  1、非启用遮挡层（这时，遮挡层的高宽 = 内容层的高宽）  
    //  2、最大化，则与遮挡层一样的高宽
    if (!this.cs.zdc || this.cs.zdh) {
        _SX.g = '';//与父同高宽
        _SX.k = '';//与父同高宽
    } else {
        _SX.g = this.cs.g
        _SX.k = this.cs.k
    }
    this.nrcRQ = this.nw.cj2(this.zdcRQ.jd.cjEZ('buju', _SX));
}
// 2.1、在内容层容器里面，创建一个标题
NW05_tcc_gt.prototype._cjNRC_tb = function () {

    this.tbJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('buju', {
        g: this.cs.tb_g, k: '', l: '1', h: '1', style: 'overflow:hidden;background-color:' + this.cs.tb_bjys
    }));

    if (this.cs.tb_pdJZ) {
        this.tbJD2 = this.nw.cj2(this.tbJD.jd.cjEZ('nr', {
            xddw: 'zzj',
        }));
        this.tbJD2.jd.xgNR_html(this.cs.tb_nr);//写入标题内容
        return;
    }
    this.tbJD.jd.xgNR_html(this.cs.tb_nr);//写入标题内容
}
// 2.2、在内容层容器里面，创建一个内容区
NW05_tcc_gt.prototype._cjNRC_st = function () {
    // let _stBQ = 'buju';
    // if (!this.cs.geli) {//不是隔离内容（不是iframe）
    //     if (!this.cs.st_yq) {//如果没有开启 引擎
    //         _stBQ = 'nr';//使用 nr标签。 会跳过 【nr标签的下游节点】的 布局、定位、事件解析。 nr是内容标签。
    //     }
    // }
    this.stJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('buju', {
        g: 'zd', k: '', l: '1', h: '2',
        style: 'background-color:' + this.cs.st_bjys + ';overflow:hidden'
    }));

    if (this.cs.geli) {
        let _geliPZ = { gk: '', frameborder: 0, style: 'overflow:auto' }
        _geliPZ.src = this.cs.yc_dizhi ? this.cs.yc_dizhi : this.cs.st_nr;
        this.stJD = this.nw.cj2(this.stJD.jd.cjEZ('iframe', _geliPZ));
        if (this.stJD.Jiedian.attachEvent) {
            this.stJD.Jiedian.attachEvent("onload", NW05_tcc_gt_iframe_zbsj);
        } else {
            this.stJD.Jiedian.onload = NW05_tcc_gt_iframe_zbsj
        }
    } else {
        this.stJD.jd.xgNR_html(this.cs.st_nr);//写入内容
    }
}

function NW05_tcc_gt_iframe_zbsj() {
    let tcc = NWHS_hqJD_tgSXzhi(this, 'rq', 'tcc');
    let gt = nw.ck.tcc.hqGT(tcc);
    if (gt) {
        gt.ycDDC();
        // setTimeout(function () {
        //     gt.ycDDC();
        // },1000);
        // gt._gx();
    }
}

// 2.3、在内容层容器里面，创建一个脚部
NW05_tcc_gt.prototype._cjNRC_jb = function () {
    this.jbJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('buju', {
        g: this.cs.jb_g, k: '', l: '1', h: '3', style: 'overflow:hidden;background-color:' + this.cs.jb_bjys
    }));
    this.jbJD.jd.xgNR_html(this.cs.jb_nr);//写入标题内容
}


// ======================↓↓↓=========================
// 2.4、在内容层容器里面，创建一个关闭按钮
NW05_tcc_gt.prototype._cjNRC_gbAN = function () {
    if (this.cs.an_gb) {
        this.gbAN = this._ngj_cjBJ('ysj,5', 'x', 'tcc_gb');
        return this.gbAN;
    }
}
// 2.5、在内容层容器里面，创建一个关闭按钮
NW05_tcc_gt.prototype._cjNRC_zdhAN = function () {
    if (this.cs.an_zdh) {
        this.zdhAN = this._ngj_cjBJ('ysj,25', '口', 'tcc_zhd');
        return this.zdhAN;
    }
}
// 在内容层容器里面，创建部件
NW05_tcc_gt.prototype._ngj_cjBJ = function (wz, fh, ajlb) {
    let _WO = this.nw.cj2(this.nrcRQ.jd.cjEZ('div', { xddw: wz, style: ' z-index: 999' }));
    _WO.jd.xgNR_html('<a href="javascript:void(0)" style="text-decoration:none" ajlb="' + ajlb + '">' + fh + '</a>');
    return _WO;
}
// ======================↑↑↑=========================

// 等待。有远程地址配置时，自动添加 等等层
// 
NW05_tcc_gt.prototype.xsDDC = function () {
    if (this.cs.yc_dizhi) {
        if (!this.ddc) {
            this.ddc = this.nw.cj2(this.nrcRQ.jd.cjEZ('buju', {
                gk: '',
                xddw: 'zsj',
                style: 'z-index: 998;overflow:hidden;background-color:' + this.cs.ddc_bjys
            }));
        }

        this.ddc.jd.xgNR_html(this.cs.ddc_nr);//写入标题内容
        this.ddc.ys.xs(1);

        this._bj.buju(this.zdcRQ)
        this._bj.buju(this.zdcRQ)
        this._dw.dw(this.zdcRQ);//立马定位
    }
}
NW05_tcc_gt.prototype.ycDDC = function () {
    if (this.cs.yc_dizhi) {
        if (this.ddc) {
            this.ddc.ys.xs(0);
        }
    }
}


NW05_tcc_gt.prototype.jiazaiNR = function (csDX) {
    if (this.cs.geli || !this.cs.yc_dizhi) {
        return;
    }
    if (!csDX) {
        csDX = this.cs.yc_cs;
    }
    this.xsDDC();
    switch (this.cs.yc_wffs) {
        case 'get':
            this.nw.ff.yc.n(this.cs.yc_dizhi, csDX, this, this.cs.yc_sjgs); break;
        default:
            this.nw.ff.yc.by(this.cs.yc_dizhi, csDX, this, this.cs.yc_sjgs); break;
    }
}

NW05_tcc_gt.prototype._03yc_qq_cg = function (shuju) {
    if (shuju) {
        if (shuju[this.cs.yc_nr_tb] != undefined) {
            this.tbJD.jd.xgNR_html(shuju[this.cs.yc_nr_tb]);
        }
        if (shuju[this.cs.yc_nr_st] != undefined) {
            this.stJD.jd.xgNR_html(shuju[this.cs.yc_nr_st]);
        }
        if (shuju[this.cs.yc_nr_jb] != undefined) {
            this.jbJD.jd.xgNR_html(shuju[this.cs.yc_nr_jb]);
        }
        this.nw.yq.zdy.zx(this.nrcRQ.Jiedian)
        this.ycDDC();
        this._ngj_bj_dw();
        this.sj.zcSJ(this.zdcRQ.Jiedian);//重新注册事件
    }
}

// ======================↑↑↑=========================

NW05_tcc_gt.prototype.tb = function (nr) {
    return this._ngj_nr(this.cs.tb_pdJZ ? this.tbJD2 : this.tbJD, nr)
}
NW05_tcc_gt.prototype.st = function (nr) {
    if (this.cs.geli) {
        if (nr == undefined) {
            return;
        }
        this.xsDDC();
        this.stJD.jd.xgSX({ src: nr })
        this.cs.yc_dizhi = nr;
        return;
    }
    return this._ngj_nr(this.stJD, nr)
}
NW05_tcc_gt.prototype.jb = function (nr) {
    return this._ngj_nr(this.jbJD, nr)
}

NW05_tcc_gt.prototype._ngj_nr = function (nwJD, nr) {
    if (nr != undefined) {
        nwJD.jd.xgNR_html(nr);
    } else {
        return nwJD.jd.hqNR_html();
    }
}

NW05_tcc_gt.prototype.xs = function (kg) {
    this.zdcRQ.ys.xs(kg);
    if (kg != 0) {
        this._ngj_bj_dw();
    }
}

NW05_tcc_gt.prototype.xsTB = function (kg) {
    this.tbJD.ys.xs(kg);
    this._ngj_bj_dw();
}

NW05_tcc_gt.prototype.xsJB = function (kg) {
    this.jbJD.ys.xs(kg);
    this._ngj_bj_dw();
}

//删除对话框
NW05_tcc_gt.prototype.gb = function () {
    // this._zt_bg = 0;
    this.sj.zxSJ(this.zdcRQ.Jiedian, 'tcc_gb', 1);
}

NW05_tcc_gt.prototype.gx = function () {
    if (this.cs.geli) {//表示 iframe
        this.st(this.cs.yc_dizhi);
        return;
    }
    //表示远程访问数据时
    if (this.cs.yc_dizhi) {
        this._ngj_sjcs()
        this.jiazaiNR();
        return;
    }
}
//随机参数
NW05_tcc_gt.prototype._ngj_sjcs = function () {
    if (this.cs.sjcs && this.cs.sjcs_ming) {
        if (!this.cs.yc_cs) {
            this.cs.yc_cs = {}
        }
        this.cs.yc_cs[this.cs.sjcs_ming] = new Date().getTime()
    }
}

//最大化|还原 对话框
NW05_tcc_gt.prototype.zdh = function () {
    if (this.cs.zdh) {//已经是最大化。则，强制还原

        //内容层在 遮挡层里面。还原时，也要把 锁定层还原到最开始的状态
        if (!this.cs.zdc) { //假值=与内容层 同尺寸
            this.zdcRQ.jd.xgSX({ g: this.cs.g, k: this.cs.k })//还原尺寸
            this.nrcRQ.jd.xgSX({ g: '', k: '' })
        } else {
            this.nrcRQ.jd.xgSX({ g: this.cs.g, k: this.cs.k })//还原尺寸
        }
    } else {
        let _pz = { g: '', k: '' };
        //内容层在 遮挡层里面。最大化之前，还要把遮挡层调整为最大尺寸。
        if (!this.cs.zdc) { //假值=与内容层 同尺寸
            this.zdcRQ.jd.xgSX(_pz)
        }
        this.nrcRQ.jd.xgSX(_pz)
    }
    this.cs.zdh = !this.cs.zdh;//取反。真变假。假变真
    this._ngj_bj_dw();
}

// 更新
NW05_tcc_gt.prototype._ngj_bj_dw = function () {
    // nw.ck.dw.stDW();//立马定位
    // this.bjdx.stBJ();
    // this.dwdx.stDW();//立马定位
    // this.bjdx.stBJ();
    // this.dwdx.stDW();//立马定位

    let rq = this.nw.cj2(this.zdcRQ.Jiedian.parentNode);

    // this._bj.buju(rq)
    // this._bj.buju(this.zdcRQ)
    // this._dw.dw(rq);//立马定位
    // this._bj.buju(this.zdcRQ)
    // this._dw.dw(rq);//立马定位
    // this._bj.buju(this.zdcRQ)
    // this._dw.dw(rq);//立马定位
    // this._bj.buju(this.zdcRQ)

    this._bj.buju(rq)
    this._bj.buju(this.zdcRQ)
    this._dw.dw(this.zdcRQ);//立马定位
    this._bj.buju(this.zdcRQ)
    this._dw.dw(this.zdcRQ);//立马定位
    this._bj.buju(this.zdcRQ)
    this._dw.dw(this.zdcRQ);//立马定位
    this._bj.buju(this.zdcRQ)
}
;
///<jscompress sourcefile="NW05_tcc_sj.js" />
//窗口-弹出层-事件管理中心
function NW05_tcc_sj(fq) {
    this.fq = fq;//nw
    this.nw = fq.nw;
    this.hc = fq.hc;//缓存。
    this.tcc_sj = '/^tcc_sj\s*[0-9a-z_]+$/i'
}

function NW05_tcc_sj_gt(sfz, gt) {
    this.sfz = sfz;
    this.gt = gt;
}

// 注册事件 与缓存
NW05_tcc_sj.prototype.bc = function (gt) {
    this.hc.push(new NW05_tcc_sj_gt(gt.zdcRQ.Jiedian, gt));//缓存
}

/**
 * 执行事件
 * @param {对象} jd 弹出层原始节点
 * @param {文本} ajlb_dh  事件代号
 * @param {真|假} sdzx  是否手动关闭（用户自己代码，调用此函数）。如果是手动关闭，是不会触发用户函数
 * @returns 
 */
NW05_tcc_sj.prototype.zxSJ = function (jd, ajlb_dh, sdzx) {
    let gt;
    let cs;
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].sfz == jd) {
            gt = this.hc[i].gt;
            cs = gt.cs;
            if (!sdzx && cs.sj) {//非手动触发（系统调用），与 参数里面配置了 用户事件

                if (/^tcc_sj\s*[0-9a-z_]+$/i.test(ajlb_dh)) {
                    ajlb_dh = NWHS_sck(ajlb_dh.substring(6));
                    if (/^[0-9.]+/.test(ajlb_dh)) {
                        ajlb_dh = Number(ajlb_dh);
                    }
                }
                // console.log('-------事件代号------------' + ajlb_dh)
                if (!cs.sj(gt, ajlb_dh)) {
                    //执行用户方法，得到一个 false，表示阻止事件执行
                    return;
                }

            }
            switch (ajlb_dh) {//按键类别 触发事件的 按键类别
                case 'tcc_gb':
                    gt._zt_bg = 0;//记录关闭状态
                    this.hc.splice(i, 1);//从数组删除    
                    // console.log(this.nw.yq.zdy.sj.hc.length)
                    this.nw.yq.zdy.sj.sc(gt.nrcRQ.Jiedian);
                    // console.log(this.nw.yq.zdy.sj.hc.length)
                    gt.zdcRQ.jd.sc();//节点上也删除
                    return;
                case 'tcc_zhd':
                    gt.zdh();
                    return;
                //隐藏    
                case 'tcc_yc':
                    gt.xs(0);
                    return;
                case 'tcc_yc_tb':
                    gt.xsTB(0);
                    return;
                case 'tcc_yc_jb':
                    gt.xsJB(0);
                    return;
                //显示
                case 'tcc_xs':
                    gt.xs(1);
                    return;
                case 'tcc_xs_tb':
                    gt.xsTB(1);
                    return;
                case 'tcc_xs_jb':
                    gt.xsJB(1);
                    return;
                //显示或隐藏。自动取反
                case 'tcc_xs_yc':
                    gt.xs();
                    return;
                case 'tcc_xs_yc_tb':
                    gt.xsTB();
                    return;
                case 'tcc_xs_yc_jb':
                    gt.xsJB();
                    return;
                //针对 ajax 与隔离 ifarme的重装加载
                case 'tcc_gx':
                    gt.gx()
                    return;
            }
        }
    }
}


// ======================↓↓↓=========================
// 创建单击事件
NW05_tcc_sj.prototype.zcSJ = function (RQ) {

    let sx = RQ.getAttributeNode('ajlb');
    if (sx && NW05_tcc_sj_pdAJLB(sx.value)) {

        RQ.onclick = NW05_tcc_sj_danji;
        // console.log(RQ)
        // console.log(RQ.onclick)
        // console.log('\n')
    }
    let _ErziM = RQ.children;//取得容器所有的子节点
    if (!_ErziM) {
        return;
    }
    for (let i = 0; i < _ErziM.length; i++) {
        if (_ErziM[i].nodeName == 'IFRAME' || _ErziM[i].nodeName == 'NR') {
            continue;
        }
        this.zcSJ(_ErziM[i]);
    }
}

function NW05_tcc_sj_danji(e) {// 单击事件
    if (this.nodeName != 'AJ' && e.target != this) {
        return;
    }
    //按键所在的弹出层
    let jd = NWHS_hqJD_tgSXzhi(this, 'rq', 'tcc');
    //按键的类别。
    let ajlb = this.getAttributeNode('ajlb');
    if (ajlb && (ajlb = NWHS_sck(ajlb.value))) {
        nw.ck.tcc.sj.zxSJ(jd, ajlb);
    }

    // if (ajlb && NW05_tcc_sj_pdAJLB(ajlb.value)) {
    //     ajlb = ajlb.value.replace(/\s+/g, "");//除所有空格
    //     ajlb = ajlb.toLowerCase();
    //     nw.ck.tcc.sj.zxSJ(jd, ajlb);
    // }
}

// ======================↑↑↑=========================
function NW05_tcc_sj_pdAJLB(ajlb) {
    if (ajlb && (ajlb = NWHS_sck(ajlb))) {
        if (/^tcc_sj\s*[0-9a-z_]+$/i.test(ajlb)) {
            return ajlb
        }
        ajlb = ajlb.toLowerCase();
        switch (ajlb) {
            //关闭
            case 'tcc_gb':
            //最大化
            case 'tcc_zhd':
            //隐藏
            case 'tcc_yc':
            case 'tcc_yc_tb':
            case 'tcc_yc_jb':
            //显示
            case 'tcc_xs':
            case 'tcc_xs_tb':
            case 'tcc_xs_jb':
            //显示或隐藏。自动取反
            case 'tcc_xs_yc':
            case 'tcc_xs_yc_tb':
            case 'tcc_xs_yc_jb':
            //针对 ajax 与隔离 ifarme的重装加载
            case 'tcc_gx':
                return ajlb;
            default: return null;
        }
    }
    return null;
}


;
///<jscompress sourcefile="NW05_tcc.js" />
//窗口-弹出层
function NW05_tcc(fq) {
    this.fq = fq;//nw
    this.nw = fq.fq;
    this.hc = [];//缓存。
    // this.sfz = 0;
    this.sj = new NW05_tcc_sj(this);
    //部分需要强行指明的类型的。比如，参数为对象，默认值是null，如果不强行指明，就会出现意外
}

NW05_tcc.prototype.cj = function (cs) {
    let gt = new NW05_tcc_gt(this, cs);
    //1、加载全局参数配置（会覆盖用户js方式配置的）
    let mrCS = this.nw.jzGJ.hqGT('tcc_mr');
    if (mrCS) {
        mrCS.zzCS(gt.cs);//装载默认配置
    }
    //2、加载全局参数配置（会覆盖用户html方式配置的）
    mrCS = this.nw.jzGJ.hqGT(cs.juese);
    if (mrCS) {
        mrCS.zzCS(gt.cs);//装载默认配置
    }
    //3、初始化参数
    cs.qd0()

    gt.qd0();
    this.sj.bc(gt);
    return gt;
}

NW05_tcc.prototype.dedai = function (nr, fq, yc) {
    let cs = new NW05_tcc_cs();//在哪个div（zszx）正面生成 弹出层，已经通过 html全局配置。
    cs.zdh = 0;
    cs.zdc = 1;
    cs.tb_pdJZ = 1;
    cs.fq = fq;

    cs.tb_xs = 1;
    cs.tb_djs = 1;
    cs.qd_yc = yc;
    cs.jb_xs = 0;
    cs.an_gb = 0;
    cs.an_zdh = 0;
    cs.tb_nr = NWHS_hqJKshijian()
    cs.st_nr = "<nr xddw='zzj' style='color:red'>" + (nr ? nr : '请等待.正在处理中...') + "</nr>"
    cs.zdc_sj = null
    cs.zdc_bjys = null
    cs.st_yq = 1;//开启内容的引擎。 true=对内容里面的节点，进行布局、定位；false=不动内容里面的东西。
    cs.k = ''
    cs.g = 120
    return this.cj(cs);
}

NW05_tcc.prototype.dhk = function (juese, fq, hs, tb, nr, aj0, aj1) {
    let cs = new NW05_tcc_cs();//在哪个div（zszx）正面生成 弹出层，已经通过 html全局配置。
    cs.fq = fq;
    cs.juese = juese;
    //非最大化
    cs.zdh = 0;
    //遮挡层
    cs.zdc = 1;         //最大化
    cs.zdc_sj = null    //没事件
    cs.zdc_bjys = null  //没背景颜色

    cs.sj = hs;

    //按键
    cs.an_zdh = 0;      //不显示最大化按键
    //头部
    cs.tb_xs = 0;       //不显示头部
    if (tb) {           //如果有头部的内容
        cs.tb_xs = 1;   //显示头部
        cs.tb_pdJZ = 1; //居中
        cs.tb_nr = tb   //内容
    }
    //身体-内容
    cs.st_nr = nr
    cs.st_yq = 1;//开启内容的引擎。 true=对内容里面的节点，进行布局、定位；false=不动内容里面的东西。

    // 脚部-显示
    cs.jb_xs = 0;
    if (aj0 == undefined || aj0) {
        cs.jb_nr = "<aj ys='xg,k=70' ajlb='tcc_gb'>" + (aj0 ? aj0 : '取消') + "</aj>";
    }
    if (aj1 == undefined || aj1) {
        cs.jb_nr = (cs.jb_nr ? cs.jb_nr + '&nbsp;&nbsp;' : '') + "<aj ys='tj,k=70' ajlb='tcc_yc'>" + (aj1 ? aj1 : '确认') + "</aj>";
    }
    if (cs.jb_nr) {
        cs.jb_nr = "<buju xddw='yz,33' g='28'>" + cs.jb_nr + "</buju>"
        cs.jb_xs = 1;
    }

    cs.k = 350
    cs.g = 200
    return this.cj(cs);
}


NW05_tcc.prototype.hqGT = function (sfz) {
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].sfz == sfz) {
            return this.hc[i].gt;
        }
    }
}

// ======================↓↓↓=========================
// ======================↑↑↑=========================;
///<jscompress sourcefile="NW05_ts.js" />
//窗口布局管理
function NW05_ts(fq) {
    this.fq = fq;//nw
    this.nw = fq.fq;
    this.hc = [];//缓存。

    this.sj_ts = 2000;
    this.sj_cuowu = -1;
    this.sj_sb = 2000;
    this.sj_cg = 2000;

    this.wz_ts = 'yxj,10,10';
    this.wz_cuowu = 'yxj,10,10';
    this.wz_sb = 'yxj,10,10';
    this.wz_cg = 'yxj,10,10';

    this.g_ts = '60px';
    this.g_cuowu = '60px';
    this.g_sb = '60px';
    this.g_cg = '60px';

    this.k_ts = '150px';
    this.k_cuowu = '150px';
    this.k_sb = '150px';
    this.k_cg = '150px';
}

// ======================↓↓↓=========================
function NW05_ts_fz_danji() {// 单击事件
    nw.ck.ts._ngj_scHC(this);
}

// 删除缓存（事件池）
NW05_ts.prototype._ngj_scHC = function (anJD) {
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].gbAN.Jiedian == anJD) {
            this.hc[i].rq.jd.sc();
            this.hc.splice(i, 1)
            return;
        }
    }
}
// ======================↑↑↑=========================

//错误-需要手动关闭 比如，服务器出问题之类，可以直接用这类。方便用户截图，求助。
NW05_ts.prototype.cuowu = function (xx, wz, g, k, sj) {
    // 信息、提示框颜色、提示框高、提示框宽、显示位置、显示时间、字体颜色、隐藏关闭按钮 
    this.cj(xx ? xx : '出错', 'black', g ? g : this.g_cuowu, k ? k : this.k_cuowu, wz ? wz : this.wz_cuowu, sj ? sj : this.sj_cuowu, 'seashell')
}

//异常。比如，删除失败。修改失败、更新失败、总之是 操作失败一类。但非服务器问题。
NW05_ts.prototype.sb = function (xx, wz, g, k, sj) {
    // 信息、提示框颜色、提示框高、提示框宽、显示位置、显示时间、字体颜色、隐藏关闭按钮 
    this.cj(xx ? xx : '操作【失败】', 'red', g ? g : this.g_sb, k ? k : this.k_sb, wz ? wz : this.wz_sb, sj ? sj : this.sj_sb, 'seashell')
}

//成功
NW05_ts.prototype.cg = function (xx, wz, g, k, sj) {
    // 信息、提示框颜色、提示框高、提示框宽、显示位置、显示时间、字体颜色、隐藏关闭按钮
    this.cj(xx ? xx : '操作【成功】', 'seagreen', g ? g : this.g_cg, k ? k : this.k_cg, wz ? wz : this.wz_cg, sj ? sj : this.sj_cg, 'seashell')
}

/**
 * 
 *  信息、提示框颜色、提示框高、提示框宽、显示位置、显示时间、字体颜色、隐藏关闭按钮
 * 
 * @param {内容} xx        提示信息
 * @param {文本} bjYanse   提示框颜色
 * @param {文本} g         提示框高 如果是数字，会自动附加px单位。如果不文本，需要自己附加单位
 * @param {文本} k         提示框宽 如果是数字，会自动附加px单位。如果不文本，需要自己附加单位
 * @param {文本} wz        显示位置
 * @param {数字} sj        显示时间 显示时间=-1时，表示不自动关闭提示框
 * @param {文本} ztYanse   字体颜色
 * @param {真假} ycGB      隐藏关闭按钮
 */
NW05_ts.prototype.cj = function (xx, bjYanse, g, k, wz, sj, ztYanse, ycGB) {
    if (!bjYanse) {
        bjYanse = 'seagreen'
    }
    if (!wz) {
        wz = this.wz_ts;
    }
    // console.log(typeof g)
    if (!g) {
        g = this.g_ts
    } else if (typeof g == 'number') {
        g = g + 'px'
    }

    if (!k) {
        k = this.k_ts
    } else if (typeof k == 'number') {
        k = k + 'px'
    }

    let tsk = this.nw.st.jd.cjEZ('div', {
        gddw: wz,
        style: 'height:' + g + ';background-color:' + bjYanse + ' ; z-index: 999;width:' + k
    })

    tsk = this.nw.cj2(tsk);


    let tsk2 = this.nw.cj2(tsk.jd.cjEZ('div', {
        xddw: 'zzj',
        style: 'color:' + ztYanse
    }));

    // 关闭代号
    let tsk3 = null;
    if (!ycGB) {
        tsk3 = this.nw.cj2(tsk.jd.cjEZ('div', {
            xddw: 'ysj,5,-3'
        }));
        tsk3.jd.xgNR_html('<a href="javascript:void(0)" style="text-decoration:none">x</a>');
        tsk3.jt.sb_dj(NW05_ts_fz_danji) //绑定一个单击事件
        this.hc.push({ rq: tsk, gbAN: tsk3 });//缓存对话框
    }

    tsk2.jd.xgNR_html(xx);
    // this.nw.ck.dw.dw(this.nw.cj2(tsk.Jiedian.parentNode));//立马定位
    // this.nw.ck.dw.dw(this.nw.cj2(tsk.Jiedian.parentNode));//立马定位
    this.nw.ck.dw.dw(tsk);//立马定位
    // console.log(tsk.Jiedian)
    if (!sj) {
        sj = this.sj_ts
    }
    if (sj == -1) {
        return;
    }
    let _wo = this;
    setTimeout(function () {
        tsk.jd.sc()
        if (!ycGB) {
            _wo._ngj_scHC(tsk3.Jiedian);
        }
    }, sj);
}

//创建一个div，布局全屏幕。
;
///<jscompress sourcefile="NW05_dhk_ht_gt.js" />
// // 用来缓存 对话框数据。
// function NW05_dhk_ht_gt(hc, rq, nr, btJD, stJD, jbJD, gbAN, zdhAN, pz_zdc, pz_zdh, pz_g, pz_k) {
//     this.hc = hc;           //缓存池
//     this.rq = rq;           //对话框 容器(遮挡层)
//     this.nr = nr;           //容器里面的 内容层
//     this.btJD = btJD;
//     this.stJD = stJD;
//     this.jbJD = jbJD;
//     this.gbAN = gbAN;       //关闭按钮
//     this.zdhAN = zdhAN;     //最大化按钮
//     this.pz_zdc = pz_zdc;   //用户的配置。 遮挡层： 真值=启用遮挡层；假值=与内容层 同尺寸
//     this.pz_zdh = pz_zdh;   //用户的配置。 最大化： 真值=最大化；假值=指定高宽。
//     this.pz_g = pz_g == 'zd' ? '' : pz_g;       //用户的配置。对话框的高
//     this.pz_k = pz_k == 'zd' ? '' : pz_k;       //用户的配置。对话框的宽
// }

// //判断是否是 关闭按钮
// NW05_dhk_ht_gt.prototype.pdAN_gb = function (anJD) {
//     return this.gbAN && this.gbAN.Jiedian == anJD;
// }

// //判断是否是 最大化按钮
// NW05_dhk_ht_gt.prototype.pdAN_zdh = function (anJD) {
//     return this.zdhAN && this.zdhAN.Jiedian == anJD;
// }

// NW05_dhk_ht_gt.prototype.bt = function (nr) {
//     return this._ngj_nr(this.btJD, nr)
// }
// NW05_dhk_ht_gt.prototype.st = function (nr) {
//     return this._ngj_nr(this.stJD, nr)
// }
// NW05_dhk_ht_gt.prototype.jb = function (nr) {
//     return this._ngj_nr(this.jbJD, nr)
// }

// NW05_dhk_ht_gt.prototype._ngj_nr = function (nwJD, nr) {
//     if (nr != undefined) {
//         nwJD.jd.xgNR_html(nr);
//     } else {
//         return nwJD.jd.hqNR_html();
//     }
// }


// NW05_dhk_ht_gt.prototype.xs = function () {
//     this.rq.ys.xs();
// }

// //删除对话框
// NW05_dhk_ht_gt.prototype.sc = function () {
//     this.rq.jd.sc();
//     for (let i = 0; i < this.hc.length; i++) {
//         if (this.hc[i].rq == this.rq) {
//             this.hc.splice(i, 1);
//         }
//     }
// }

// //最大化|还原 对话框
// NW05_dhk_ht_gt.prototype.zdh = function () {
//     if (this.pz_zdh) {//已经是最大化。则，强制还原

//         //内容层在 遮挡层里面。还原时，也要把 锁定层还原到最开始的状态
//         if (!this.pz_zdc) { //假值=与内容层 同尺寸
//             this.rq.jd.xgSX({ g: this.pz_g, k: this.pz_k })//还原尺寸
//             this.nr.jd.xgSX({ g: '', k: '' })
//         } else {
//             this.nr.jd.xgSX({ g: this.pz_g, k: this.pz_k })//还原尺寸
//         }
//     } else {
//         let _pz = { g: '', k: '' };
//         //内容层在 遮挡层里面。最大化之前，还要把遮挡层调整为最大尺寸。
//         if (!this.pz_zdc) { //假值=与内容层 同尺寸
//             this.rq.jd.xgSX(_pz)
//         }
//         this.nr.jd.xgSX(_pz)
//     }
//     this.pz_zdh = !this.pz_zdh;//取反。真变假。假变真
//     this._gx();
// }

// // 更新
// NW05_dhk_ht_gt.prototype._gx = function () {
//     nw.ck.bj.stBJ();
//     nw.ck.dw.stDW();//立马定位
// };
///<jscompress sourcefile="NW05_dhk.js" />
//窗口布局管理
function NW05_dhk(fq) {
    this.fq = fq;//nw
    this.nw = fq.fq;

    this.hc = [];//缓存。

    this.wz_dhk = 'zzj';
    this.g_dhk = '180px ';
    this.k_dhk = '350px ';
    this.ys_dhk = 'rgb(255, 244, 244)' //锁定层颜色-无

    //标题
    this.g_dhk_bt = '35px';//默认高
    this.ys_dhk_bt = 'rgb(227, 189, 245)'//默认背景颜色
    //内容
    this.ys_dhk_nr = 'rgb(243, 217, 255)';
    //脚部
    this.g_dhk_jb = '35px';
    this.ys_dhk_jb = 'rgb(220, 159, 248)'
}

/**
 * @param {真假} fq  
 * @param {真假} geli  
 * @param {真假} zdh 最大化。 假=非最大化（默认）；真=最大化
 * @param {真假} zdc 遮挡层。 假=与内容层同尺寸；  真=与父同尺寸
 * @param {文本} wz  定位。 
 * @param {数字|文本} dhkG 对话框 高    
 * @param {数字|文本} dhkK 对话框 宽
 * @param {数字|文本} btG  标题 高
 * @param {数字|文本} jbG  脚部 高
 * @param {文本} btNR 标题内容
 * @param {文本} stNR 身体内容
 * @param {文本} dizhi 地址
 * @param {文本} fwfs 请示方式（默认post)
 * @param {文本} jbNR 脚部内容
 * @param {文本} ys_zdc      遮挡层背景颜色
 * @param {文本} ys_bt   标题层背景颜色
 * @param {文本} ys_nr   身体层背景颜色
 * @param {文本} ys_jb   脚部层背景颜色
 * @param {真假} ycGBan  隐藏关闭按钮。     假=不隐藏；真=隐藏
 * @param {真假} ycZDHan 隐藏最大化按钮。   假=不隐藏；真=隐藏
 * @returns 
 */
NW05_dhk.prototype.cj = function (fq, geli, zdh, zdc, wz, dhkG, dhkK, btG, jbG, btNR, stNR, dizhi, fwfs, jbNR, ys_zdc, ys_bt, ys_nr, ys_jb, ycGBan, ycZDHan, ycBT, ycJB) {
    if (!wz) {
        wz = this.wz_dhk;
    }
    dhkG = this._gshGK(dhkG, this.g_dhk);//锁定层的高（如果非窗口最大化时）,内容层的高
    dhkK = this._gshGK(dhkK, this.k_dhk);//锁定层的宽（如果非窗口最大化时）,内容层的宽
    if (fq && !fq.Jiedian) {
        fq = this.nw.cj2(fq);
    }
    let fqRQ = fq ? fq : this.nw.st;
    let gt = new NW05_dhk_gt(this.nw, this.hc, fqRQ, zdc, zdh, dhkG, dhkK);
    if (fqRQ != this.nw.st) {
        gt.zdcDW = 'xddw'
    }
    gt.wz = wz;
    gt.geli = geli;
    gt.dizhi = dizhi;
    gt.zdc_ys = ys_zdc ? ys_zdc : this.ys_dhk;//遮挡层颜色
    gt.bt_g = this._gshGK(btG, this.g_dhk_bt);//标题高
    gt.bt_ys = ys_bt ? ys_bt : this.ys_dhk_bt;//标题背景颜色
    gt.nr_ys = ys_nr ? ys_nr : this.ys_dhk_nr;//内容背景颜色
    gt.jb_g = this._gshGK(jbG, this.g_dhk_jb);//脚部高
    gt.jb_ys = ys_jb ? ys_jb : this.ys_dhk_bt;//脚部背景颜色

    gt._cjZDC();
    gt._cjNRC();
    gt._cjNRC_tb(btNR);
    gt._cjNRC_st(stNR);
    gt._cjNRC_jb(jbNR);
    gt._cjNRC_gbAN(ycGBan)
    gt._cjNRC_zdhAN(ycZDHan);
    gt.jiazaiNR(null, fwfs);

    if (ycBT) {
        gt.xsBT();
    }
    if (ycJB) {
        gt.xsJB();
    }
    this.zcSJ(gt)

    gt._gx();
    return gt;
}

/**
 * 如果值为数字，自动附加px单位；
 * 如果值为假值，自动附上【默认值】
 * 
 * @param {文本|数字} zhi 值
 * @param {未知} mrZhi 默认值
 */
NW05_dhk.prototype._gshGK = function (zhi, mrZhi) {
    if (!zhi) {
        return mrZhi
    } else if (typeof zhi == 'number') {
        return zhi + 'px'
    } else {
        return zhi
    }
}


// ======================↓↓↓=========================
// 创建单击事件
NW05_dhk.prototype.zcSJ = function (hcDX) {
    if (hcDX.gbAN) {
        hcDX.gbAN.jt.sb_dj(NW05_dhk_fz_danji_gb) //绑定一个单击事件
    }
    if (hcDX.zdhAN) {
        hcDX.zdhAN.jt.sb_dj(NW05_dhk_fz_danji_zdh) //绑定一个单击事件
    }
    if (hcDX.gbAN || hcDX.zdhAN) {
        this.hc.push(hcDX);//缓存对话框
    }
}

function NW05_dhk_fz_danji_gb() {// 单击事件-关闭窗口
    nw.ck.dhk._ngj_scHC(this);
}
function NW05_dhk_fz_danji_zdh() {// 单击事件-最大化窗口|还原窗口
    nw.ck.dhk._ngj_zdh(this);
}

// 删除缓存（事件池）
NW05_dhk.prototype._ngj_zdh = function (anJD) {
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].pdAN_zdh(anJD)) {
            this.hc[i].zdh()
            return;
        }
    }
}

// 删除缓存（事件池）
NW05_dhk.prototype._ngj_scHC = function (anJD) {
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].pdAN_gb(anJD)) {
            this.hc[i].sc();
            return;
        }
    }
}
// ======================↑↑↑=========================;
///<jscompress sourcefile="NW05_dhk_gt.js" />
// 用来缓存 对话框数据。
function NW05_dhk_gt(nw, hc, fq, pz_zdc, pz_zdh, pz_g, pz_k) {
    this.nw = nw;
    this.hc = hc;           //缓存池

    this.fq = fq;           //父亲容器。即，对话框是 fq的儿子
    this.zdcRQ = null;           //对话框 容器(遮挡层)
    this.nrcRQ = null;           //容器里面的 内容层
    this.btJD = null;
    this.stJD = null;
    this.jbJD = null;
    this.gbAN = null;            //关闭按钮
    this.zdhAN = null;           //最大化按钮

    this.zdcDW = 'gddw';       //定位：固定定位 gddw； 相对定位 xddw
    this.wz = 'zzj'         //位置：zzj表示正中间

    this.geli = false;//隔离。 真值=表示内容区嵌入一个iframe; 假值=不嵌入iframe
    this.dizhi = ''

    this.zdc_ys = 'blue'    //遮挡层颜色
    //标题
    this.bt_g = '35px';//默认高
    this.bt_ys = 'rgb(227, 189, 245)'//默认背景颜色
    //内容
    this.nr_ys = 'rgb(243, 217, 255)';
    //脚部
    this.jb_g = '35px';
    this.jb_ys = 'rgb(220, 159, 248)'

    this.pz_zdc = pz_zdc;   //用户的配置。 遮挡层： 真值=启用遮挡层；假值=与内容层 同尺寸
    this.pz_zdh = pz_zdh;   //用户的配置。 最大化： 真值=最大化；假值=指定高宽。
    this.pz_g = pz_g == 'zd' ? '' : pz_g;       //用户的配置。对话框的高
    this.pz_k = pz_k == 'zd' ? '' : pz_k;       //用户的配置。对话框的宽
}

// ======================↓↓↓=========================
//1、创建遮挡层
NW05_dhk_gt.prototype._cjZDC = function () {
    //创建属性
    let _SX = { style: 'background-color:' + this.zdc_ys + ' ; z-index: 999;position: absolute;' }
    _SX[this.zdcDW] = this.wz;
    if (this.pz_zdc || this.pz_zdh) {   //最大化，或启用遮挡层时
        _SX.g = '';//与父同高宽
        _SX.k = '';//与父同高宽
    } else {
        _SX.g = this.pz_g
        _SX.k = this.pz_k
    }
    this.zdcRQ = this.nw.cj2(this.fq.jd.cjEZ('div', _SX));
}

//2、在遮挡层 内，创建一个【内容层】容器
NW05_dhk_gt.prototype._cjNRC = function () {
    let _SX = {}
    //如果遮挡层与父同尺寸（100%）。那么，用户配置的位置，直接调整 内容层
    _SX.xddw = this.pz_zdc ? this.wz : "zzj"
    //  1、非启用遮挡层（这时，遮挡层的高宽 = 内容层的高宽）  
    //  2、最大化，则与遮挡层一样的高宽
    if (!this.pz_zdc || this.pz_zdh) {
        _SX.g = '';//与父同高宽
        _SX.k = '';//与父同高宽
    } else {
        _SX.g = this.pz_g
        _SX.k = this.pz_k
    }
    this.nrcRQ = this.nw.cj2(this.zdcRQ.jd.cjEZ('div', _SX));
}
// 2.1、在内容层容器里面，创建一个标题
NW05_dhk_gt.prototype._cjNRC_tb = function (nr) {
    this.btJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('div', {
        g: this.bt_g, k: '', l: '1', h: '1', style: 'background-color:' + this.bt_ys
    }));
    this.btJD.jd.xgNR_html(nr);//写入标题内容
}
// 2.2、在内容层容器里面，创建一个内容区
NW05_dhk_gt.prototype._cjNRC_st = function (nr) {
    this.stJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('div', {
        g: 'zd', k: '', l: '1', h: '2',
        style: 'background-color:' + this.nr_ys + ';overflow:' + (this.geli ? 'hidden' : 'auto')
    }));
    if (this.geli) {
        let _geliPZ = {
            gk: '',
            frameborder: 0,
            style: 'background-color:' + this.nr_ys + ';overflow:auto'
        }
        _geliPZ.src = this.dizhi;
        this.stJD = this.nw.cj2(this.stJD.jd.cjEZ('iframe', _geliPZ));
    } else {
        this.stJD.jd.xgNR_html(nr);//写入内容
    }
}
// 2.3、在内容层容器里面，创建一个脚部
NW05_dhk_gt.prototype._cjNRC_jb = function (nr) {
    this.jbJD = this.nw.cj2(this.nrcRQ.jd.cjEZ('div', {
        g: this.jb_g, k: '', l: '1', h: '3', style: 'background-color:' + this.jb_ys
    }));
    this.jbJD.jd.xgNR_html(nr);//写入标题内容
}
// 2.4、在内容层容器里面，创建一个关闭按钮
NW05_dhk_gt.prototype._cjNRC_gbAN = function (ycAN) {
    if (ycAN) {
        return null;
    }
    this.gbAN = this._ngj_cjBJ('ysj,5', 'x');
    return this.gbAN;
}
// 2.5、在内容层容器里面，创建一个关闭按钮
NW05_dhk_gt.prototype._cjNRC_zdhAN = function (ycAN) {
    if (ycAN) {
        return null;
    }
    this.zdhAN = this._ngj_cjBJ('ysj,25', '口');
    return this.zdhAN;
}
// 在内容层容器里面，创建部件
NW05_dhk_gt.prototype._ngj_cjBJ = function (wz, fh) {
    let _WO = this.nw.cj2(this.nrcRQ.jd.cjEZ('div', { xddw: wz }));
    _WO.jd.xgNR_html('<a href="javascript:void(0)" style="text-decoration:none">' + fh + '</a>');
    return _WO;
}

NW05_dhk_gt.prototype.jiazaiNR = function (csDX, fwLX) {
    if (this.geli) {
        return;
    }
    if (!fwLX) {
        fwLX = 'get'
    }
    switch (fwLX) {
        case 'get':
            this.nw.ff.yc.n(this.dizhi, csDX, this, 'json'); break;
        default:
            this.nw.ff.yc.by(this.dizhi, csDX, this, 'json'); break;
    }

}

NW05_dhk_gt.prototype._03yc_qq_cg = function (shuju) {
    if (shuju) {
        if (shuju.bt || shuju.BT) {
            this.btJD.jd.xgNR_html(shuju.bt ? shuju.bt : shuju.BT);
        }
        if (shuju.nr || shuju.NR) {
            this.stJD.jd.xgNR_html(shuju.nr ? shuju.nr : shuju.NR);
        }
        if (shuju.jb || shuju.JB) {
            this.jbJD.jd.xgNR_html(shuju.jb ? shuju.jb : shuju.JB);
        }
        this._gx();
    }
}



// ======================↑↑↑=========================

//判断是否是 关闭按钮
NW05_dhk_gt.prototype.pdAN_gb = function (anJD) {
    return this.gbAN && this.gbAN.Jiedian == anJD;
}

//判断是否是 最大化按钮
NW05_dhk_gt.prototype.pdAN_zdh = function (anJD) {
    return this.zdhAN && this.zdhAN.Jiedian == anJD;
}

NW05_dhk_gt.prototype.bt = function (nr) {
    return this._ngj_nr(this.btJD, nr)
}
NW05_dhk_gt.prototype.st = function (nr) {
    if (this.geli) {
        this.stJD.jd.xgSX({ src: nr })
        return;
    }
    return this._ngj_nr(this.stJD, nr)
}
NW05_dhk_gt.prototype.jb = function (nr) {
    return this._ngj_nr(this.jbJD, nr)
}

NW05_dhk_gt.prototype._ngj_nr = function (nwJD, nr) {
    if (nr != undefined) {
        nwJD.jd.xgNR_html(nr);
    } else {
        return nwJD.jd.hqNR_html();
    }
}


NW05_dhk_gt.prototype.xs = function () {
    this.zdcRQ.ys.xs();
    this._gx();
}

NW05_dhk_gt.prototype.xsBT = function () {
    this.btJD.ys.xs();
    this._gx();
}

NW05_dhk_gt.prototype.xsJB = function () {
    this.jbJD.ys.xs();
    this._gx();
}

//删除对话框
NW05_dhk_gt.prototype.sc = function () {
    this.zdcRQ.jd.sc();
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].rq == this.zdcRQ) {
            this.hc.splice(i, 1);
        }
    }
}

//最大化|还原 对话框
NW05_dhk_gt.prototype.zdh = function () {
    if (this.pz_zdh) {//已经是最大化。则，强制还原

        //内容层在 遮挡层里面。还原时，也要把 锁定层还原到最开始的状态
        if (!this.pz_zdc) { //假值=与内容层 同尺寸
            this.zdcRQ.jd.xgSX({ g: this.pz_g, k: this.pz_k })//还原尺寸
            this.nrcRQ.jd.xgSX({ g: '', k: '' })
        } else {
            this.nrcRQ.jd.xgSX({ g: this.pz_g, k: this.pz_k })//还原尺寸
        }
    } else {
        let _pz = { g: '', k: '' };
        //内容层在 遮挡层里面。最大化之前，还要把遮挡层调整为最大尺寸。
        if (!this.pz_zdc) { //假值=与内容层 同尺寸
            this.zdcRQ.jd.xgSX(_pz)
        }
        this.nrcRQ.jd.xgSX(_pz)
    }
    this.pz_zdh = !this.pz_zdh;//取反。真变假。假变真
    this._gx();
}

// 更新
NW05_dhk_gt.prototype._gx = function () {
    // nw.ck.dw.stDW();//立马定位
    this.nw.ck.bj.stBJ();
    this.nw.ck.dw.stDW();//立马定位
    this.nw.ck.bj.stBJ();
    this.nw.ck.dw.stDW();//立马定位

    this.nw.ck.bj.buju(this.zdcRQ)
    this.nw.ck.dw.dw(this.zdcRQ);//立马定位
    this.nw.ck.bj.buju(this.zdcRQ)
    this.nw.ck.dw.dw(this.zdcRQ);//立马定位
};
///<jscompress sourcefile="NW05.js" />
//窗口管理
function NW05(fq) {
    this.fq = fq;//nw
    this.bj = new NW05_bj(this);//尺寸管理
    this.dw = new NW05_dw(this);
    this.tcc = new NW05_tcc(this);
    this.ts = new NW05_ts(this);
    // this.dhk = new NW05_dhk(this);
}
;
///<jscompress sourcefile="NWqd_tz_gj.js" />
function NWqd_tz_gj(QJPZ) {
    //{对象} this.QJPZ  全局配置
    this.QJPZ = QJPZ;
    /**
     * 从对象中，取出 路径指定的对象（比如 DD对象）。
     * @param {对象} _DX 对象
     * @param {文本} lujing 路径 比如："ab.cd.ee.DD"
     * @returns 对象|null
     */
    this._ngj_hqPZ = function (_DX, lujing) {
        let JGdx = _DX;//我们要的配置（对象。具体配置在对象里面）
        let _ljSZ = lujing.split(".");
        for (let i = 0; i < _ljSZ.length; i++) {
            if (_ljSZ[i]) {
                JGdx = JGdx[_ljSZ[i]];
                if (!JGdx) {
                    return null;
                }
            }
        }
        return JGdx;
    }

    /**
      * 把lujing指向的对象的 方法（地址），复制一份到 YTdx
      * @param {对象} YTdx 源头对象
      * @param {文本} lujing 路径 比如："ab.cd.ee.DD"
      */
    this.tzFF = function (YTdx, lujing) {
        if (!this.QJPZ || !YTdx) {
            console.log('NW00.js:_ngj_tzDX(): 没有源配置，或没有被拓展的对象。无法执行拓展！ ')
            return;
        }

        let _pzDX = lujing;//用户传入的 自定义方法对象|路径
        if (typeof lujing == 'string') {//如果是路径。
            _pzDX = this._ngj_hqPZ(this.QJPZ, lujing);//找到路径所绑定的对象。
        }


        if (_pzDX) {
            //_njk_tuozhan_qd0_ 方法，是拓展对象，自动调用的方法（在拓展完成后），假如，源头对象已经 存在这个方法，一定会被拓展方法覆盖，
            //所以，开始拓展前，如果源头对象存在 _njk_tuozhan_qd0_，先保存到临时对象中。
            let dxFF;
            let leiFF;
            let qd0Ming = '_njk_qd0_tuozhan_';
            if (YTdx[qd0Ming]) {
                dxFF = YTdx[qd0Ming];				//对象方法 		不是对象方法，就是类方法
                leiFF = YTdx.__proto__[qd0Ming];	//类方法 		不是对象方法，就是类方法
            }
            //开始拓展 源头对象 的方法
            for (let ming in _pzDX) {
                if (ming == qd0Ming) {//先不拓展 这个方法
                    continue;
                }
                if (_pzDX.__proto__[ming]) {
                    YTdx.__proto__[ming] = _pzDX.__proto__[ming];//用户写的是类方法，则以类方法对接
                } else {
                    YTdx[ming] = _pzDX[ming];//用户写的是 对象方法，则以对象方法对接
                }
            }
            //拓展完后，检测拓展配置（对象），是否存在 _njk_tuozhan_qd0_，如果存在，则，一定是拓展到了 _YTdx（源头对象）里。
            if (_pzDX[qd0Ming]) {
                if (leiFF) {
                    YTdx.__proto__[qd0Ming] = _pzDX[qd0Ming];
                    YTdx[qd0Ming]();
                    YTdx.__proto__[qd0Ming] = leiFF;//还原 自己的
                } else if (dxFF) {
                    YTdx[qd0Ming] = _pzDX[qd0Ming];
                    YTdx[qd0Ming]();
                    YTdx[qd0Ming] = dxFF; //还原 自己的
                } else {
                    if (_pzDX.__proto__[qd0Ming]) {
                        YTdx.__proto__[qd0Ming] = _pzDX[qd0Ming];
                        YTdx[qd0Ming]();
                        // _YTdx.__proto__[qd0Ming] = undefined;
                        delete YTdx.__proto__[qd0Ming];
                    } else {
                        YTdx[qd0Ming] = _pzDX[qd0Ming];
                        YTdx[qd0Ming]();
                        // _YTdx[qd0Ming] = undefined;
                        delete YTdx[qd0Ming];
                    }
                }
            }
            _pzDX = undefined;
        }
    }
};
///<jscompress sourcefile="NWqd_tz_jd.js" />
// 当我们new一个 nw节点时，需要给它们拓展方法
function NWqd_tz_jd(TZgj) {
    this._gj = TZgj;//拓展工具。方便拓展方法。
    this.rq = null; //1、nw对象-容器 
    this.gj = null; //2、nw对象-工具
    this.jd = null; //3、nw对象-节点
    this.ys = null; //4、nw对象-样式
    this.jt = null; //5、nw对象-监听
    this.z = null;  //6、nw对象-值
}

NWqd_tz_jd.prototype.jiazaiPZdx = function (QJPZ) {
    this._ngj_pz(QJPZ, 'rq')
    this._ngj_pz(QJPZ, 'gj')
    this._ngj_pz(QJPZ, 'jd')
    this._ngj_pz(QJPZ, 'ys')
    this._ngj_pz(QJPZ, 'jt')
    this._ngj_pz(QJPZ, 'z')
}

//外部只会传入新创建的nw节点
NWqd_tz_jd.prototype.tz = function (nwJD) {
    if (this.rq) {//1、nw对象-容器 
        this._gj.tzFF(nwJD, this.rq);
    }
    if (this.gj) {//2、nw对象-工具
        this._gj.tzFF(nwJD.gj, this.gj);
    }
    if (this.jd) {//3、nw对象-节点
        this._gj.tzFF(nwJD.jd, this.jd);
    }
    if (this.ys) {//4、nw对象-样式
        this._gj.tzFF(nwJD.ys, this.ys);
    }
    if (this.jt) {//5、nw对象-监听
        this._gj.tzFF(nwJD.jt, this.jt);
    }
    if (this.z) {//6、nw对象-值
        this._gj.tzFF(nwJD.z, this.z);
    }
}

//从全局拓展配置中，复制 指定路径的对象方法，到dxMing中。
NWqd_tz_jd.prototype._ngj_pz = function (QJPZ, dxMing, lujing) {
    lujing = "NW02." + (lujing ? lujing : dxMing);//最后的合成路径，一定是：
    // "NW02.rq"    //nw对象-容器
    // "NW02.gj"    //nw对象-工具
    // "NW02.jd"    //nw对象-节点
    // "NW02.ys"    //nw对象-样式
    // "NW02.jt"    //nw对象-监听
    // "NW02.z"     //nw对象-值
    let _pzDX = this._gj._ngj_hqPZ(QJPZ, lujing);//找到路径所绑定的对象。
    if (_pzDX) {
        this[dxMing] = {}
        this._gj.tzFF(this[dxMing], _pzDX);
    }
};
///<jscompress sourcefile="NWqd_jiazaiPZ_gt.js" />
//用于缓存的个体封装
function NWqd_jiazaiPZ_gt(jzGJ, juese, jd, csM) {
    this.jzGJ = jzGJ;
    this.juese = juese;
    this.jd = jd;
    this.csM = csM
}
// 判断 这个【个体】是否我们要找的【个体】
NWqd_jiazaiPZ_gt.prototype.pd = function (jueseZhi) {
    return this.juese == jueseZhi;
}

/**
 * 装载参数（用户配置）
 * 装载html的PZ节点的配置,到dx中来
 * @param {对象} dx  用户的对象
 */
NWqd_jiazaiPZ_gt.prototype.zzCS = function (dx) {
    // dx对象里面，是否存在 协定方法：__hqCSlx
    // 这个方法 主要规定了 dx对象xx属性 属于什么类型。  
    // 比如，属性dx.a=null ，但a却是数字。 怎么办？ 通过 __hqCSlx(a) 返回 number 类型。
    let zhenjia = new Boolean(dx['__hqCSlx']);
    let lx;
    if (dx) {
        for (let ming in dx) {
            if (this.csM[ming] == undefined) {
                continue;
            }
            if (zhenjia) {
                lx = dx.__hqCSlx(ming)
                if (!lx) {
                    lx = typeof dx[ming];
                }
            }
            dx[ming] = this.hqCSzhi(ming, lx)
        }
    }
}


//获取参数 对象
NWqd_jiazaiPZ_gt.prototype.hqCSM = function () {
    return this.csM;
}
//获取参数 对象
NWqd_jiazaiPZ_gt.prototype.hqCSzhi = function (ming, lx) {
    if (!this.csM) {
        return undefined;
    }
    if (lx) {
        if (typeof this.csM[ming] == lx) {
            return this.csM[ming];
        }
        let _zhi = this.csM[ming];
        switch (lx) {
            case 'boolean':
                this.csM[ming] = this._zh_zhenjia(_zhi); break;
            case 'number':
                this.csM[ming] = Number(_zhi); break;
            case 'object':
                this.csM[ming] = this._zh_shiti(_zhi); break;
            // case 'string'://默认就是 string，所以，不可能到这一步。
            //     console.log('string=' + this.csM[ming]); break;
            // case 'undefined': //lx为真才到switch中来。这一步不可能
            //     console.log('undefined=' + this.csM[ming]); break;
            case 'function':
                if (!this.csM[ming]) {
                    return null;
                }
                try {
                    this.csM[ming] = eval(_zhi);//取nw_jx空间地址
                } catch (e) {
                    console.error('你在【弹出层-参数】对象里面，配置了不存在的函数名：' + this.sj)
                    this.csM[ming] = null;
                }
        }
    }
    return this.csM[ming];

}



//转换 实体
NWqd_jiazaiPZ_gt.prototype._zh_shiti = function (wb) {
    if (null == wb || wb == '') {
        return null;
    }
    return new Function('return ' + wb)();
}

//转换 真假
NWqd_jiazaiPZ_gt.prototype._zh_zhenjia = function (str) {
    if (null == str || str == '' || /^(false)|0$/i.test(str)) {
        return false;
    }
    return true;
}

//更新参数
NWqd_jiazaiPZ_gt.prototype.gxCSM = function () {
    this.csM = jzGJ.hqJDpz(this.jd);
};
///<jscompress sourcefile="NWqd_jiazaiPZ.js" />
function NWqd_jiazaiPZ(fq) {
    this.nw = fq;
    this.stJD = null;
    this.wgj = fq.gj;
    this.pz = [];
}

// ======================↓↓↓=========================
//需要文档准备好后，执行。
NWqd_jiazaiPZ.prototype.qd0 = function () {
    // <PZ juese>，只在body下
    this.stJD = document.getElementsByTagName('body')[0];
    this._zbPZ();
}
//缓存【所有的 pz节点】
NWqd_jiazaiPZ.prototype._zbPZ = function () {
    let _ErziM = this.stJD.children;
    let _sx;
    let _jdCS;
    for (let i = 0; i < _ErziM.length; i++) {
        /*    
           所有的参数=this.hqJDcs(【 <PZ juese> 】

           <PZ juese>

            1、【内容直接配置】：
                a=1;b=2;c=4;
            2、【特殊的参数值】：
                <pz cs="属性名1"> 属性值1 </pz>
                <pz cs="属性名2"> 属性值2 </pz>
                
           </PZ> 

           */
        if (_ErziM[i].nodeName == 'PZ' && (_sx = _ErziM[i].getAttributeNode('juese'))) {
            _jdCS = this.hqJDcs(_ErziM[i])
            this.pz.push(new NWqd_jiazaiPZ_gt(this, _sx.value, _ErziM[i], _jdCS))
        }
    }
}

//获取指定节点的 参数（用户配置的）。
// 以[;；]作为分割，切割字符串。
// 再以=分割，切割字符串（名=值）
// 装入对象。返回
NWqd_jiazaiPZ.prototype.hqJDcs = function (jd) {
    let _wbM = jd.childNodes; //取出所有的子节点。
    //开始找 文本节点。
    let nr = '';
    let jg;
    let pz = null;//存放用户配置的参数。对象
    let sx = null;

    /*    
       所有的参数=this.hqJDcs(【 <PZ juese> 】

       <PZ juese>

        1、【内容直接配置】：
            a=1;b=2;c=4;
        2、【特殊的参数值】：
            <pz cs="属性名1"> 属性值1 </pz>
            <pz cs="属性名2"> 属性值2 </pz>
       </PZ> 
       */

    //1、读取节点的所有文本。合并在一起。
    for (let i = 0; i < _wbM.length; i++) {
        // a=1;b=2;c=4;
        if (_wbM[i].nodeType == 3) { //找到文本节点。.replace(/[\r\n]/g, "")
            jg = NWHS_sck(_wbM[i].nodeValue, 1)//replace(/(^\s*)|(\s*$)|([\r\n]*)/g, "")
            // jg = _wbM[i].nodeValue.replace(/[\r\n]*/g, "")
            if (jg) {
                nr += jg;
            }
            continue;
        }
        // <pz cs="属性名1"> 属性值1 </pz>
        if (_wbM[i].nodeName == 'PZ' && (sx = _wbM[i].getAttributeNode('cs'))) {
            if (pz == null) {
                pz = {};
            }
            pz[NWHS_sck(sx.value)] = NWHS_sck(_wbM[i].innerHTML, 1)//replace(/(^\s*)|(\s*$)|([\r\n]*)/g, "")
        }

    }

    if (nr) {
        //2、分析文本，从中切割出来 用户配置的参数 并返回
        if (pz == null) {
            pz = {};
        }
        let csM = nr.split(/[;；]{1}/g);// csM=['a=1','b=2','c=3']
        let yiduiPZ;
        for (let i = 0; i < csM.length; i++) {
            csM[i] = NWHS_sck(csM[i])
            if (csM[i]) {
                yiduiPZ = csM[i].split(/=/);// yiduiPZ=['a','1'].......
                if (yiduiPZ[0] = NWHS_sck(yiduiPZ[0])) {
                    pz[yiduiPZ[0]] = yiduiPZ.length == 2 ? NWHS_sck(yiduiPZ[1]) : null
                }
            }
        }
    }


    return pz;
}
// ======================↑↑↑=========================
// 返回的是 NWqd_jiazaiPZ_gt 对象
NWqd_jiazaiPZ.prototype.hqGT = function (jueseZhi) {
    for (let i = 0; i < this.pz.length; i++) {
        if (this.pz[i].pd(jueseZhi)) {
            return this.pz[i];
        }
    }
}

//取得参数
NWqd_jiazaiPZ.prototype.hqCS = function (jueseZhi) {
    let gt = this.hqGT(jueseZhi);
    return gt ? gt.hqCSM() : null;
};
///<jscompress sourcefile="NWqd.js" />
//防重名。
function NWqd(_TZ_) {
	this._XT_PZ_TZ = _TZ_;
	this._tz = new NWqd_tz_gj(_TZ_);
	this.tzJD = new NWqd_tz_jd(this._tz);//缓存拓展的方法。当new一个nw节点时，给它们拓展方法

	this.mk = new NW00();		//模块、对象缓存
	this.gj = new NW01();		//工具
	this.jzGJ = new NWqd_jiazaiPZ(this);//配置工具 需要放到 this.gj 后面。

	this.ff = new NW03(this);	//访问
	this.yq = new NW04(this);
	this.ck = new NW05(this);	//窗口
	this.znbd = new NW06(this);	//智能表单
	this.jdzx = [];//单例模块，节点中心
	this.st = null;		//body
	this.gen = null;	//html
	this.gdtK = 0;		//滚动条宽

	/**
	 * 打印信息
	 * @param {文本} nr 打印的内容
	 */
	this.dy = NWqd_dy
}

//默认单例模式
NWqd.prototype.cj = function (Jiedian) {
	if (typeof Jiedian == 'string') {
		Jiedian = document.getElementById(Jiedian);
	}
	let _DX = this.jdzx_hq(Jiedian);
	if (_DX) {
		// console.log('从单例中，找到你需要的对象：')
		// console.log(_DX)
		return _DX;
	}
	_DX = new NW02(Jiedian, this);
	this.tzJD.tz(_DX);//拓展用户指定的方法。
	this.jdzx.push(_DX);
	return _DX;
}

//非单例模式
NWqd.prototype.cj2 = function (Jiedian) {
	if (typeof Jiedian == 'string') {
		Jiedian = document.getElementById(Jiedian);
	}
	let _DX = new NW02(Jiedian, this);
	this.tzJD.tz(_DX);//拓展用户指定的方法。
	return _DX;
}


//获取模块
NWqd.prototype.hqMK = function (sfz) {
	return this.mk.hqMK(sfz);
}
//删除模块
NWqd.prototype.scMK = function (sfz) {
	this.mk.scMK(sfz);
}

//-----------------------------------------------------------

//启动引擎
NWqd.prototype.qdYQ = function () {
	this.yq.qdRW();
};
///<jscompress sourcefile="_dl.js" />
// 单例模式

/**
 * 从this.jdzx中，找到 nw节点——通过比较 Jiedian
 * @param {对象} Jiedian 原始节点
 */
NWqd.prototype.jdzx_hq = function (Jiedian) {
    for (let i = 0; i < this.jdzx.length; i++) {
        if (this.jdzx[i].Jiedian == Jiedian) {
            return this.jdzx[i]
        }
    }
    return null;
}

/**
 * 从this.jdzx中，删除 nw节点——通过比较 Jiedian
 * @param {对象} Jiedian 原始节点
 */
NWqd.prototype.jdzx_sc = function (Jiedian) {
    for (let i = 0; i < this.jdzx.length; i++) {
        if (this.jdzx[i].Jiedian == Jiedian) {
            this.jdzx.splice(i, 1);
            // console.log('已经从缓存中，删除本节点对象-nw节点')
        }
    }
};
///<jscompress sourcefile="_qd.js" />
//框架初始化
NWqd.prototype.qd0 = function () {
	this.gen = this.cj(document.getElementsByTagName('html')[0])
	this.st = this.cj(document.getElementsByTagName('body')[0])
	this._qd0_gdtK();	//计算滚动条宽
	this._qd0_wys();	//生成外样式

	this.jzGJ.qd0();	//加载配置
	this.yq.zdy.qd0();  //自定义标签-按键标签
	this.znbd.qd0();	//智能表单
}

/**
 * 计算滚动条宽
 */
NWqd.prototype._qd0_gdtK = function () {
	let _linJD = document.createElement('div'),
		styles = { width: '30px', height: '30px', overflowY: 'scroll' },
		i;
	for (i in styles) _linJD.style[i] = styles[i];
	document.body.appendChild(_linJD);
	this.gdtK = _linJD.offsetWidth - _linJD.clientWidth;
	_linJD.remove();
}

/**
 * 生成外样式
 */
NWqd.prototype._qd0_wys = function () {
	let wysJD = document.createElement("style");
	let _SX = document.createAttribute('type'); //创建一个新的属性
	_SX.value = "text/css";
	wysJD.setAttributeNode(_SX); //加入属性到节点里


	let _wys = "buju {display: block;overflow: hidden;}";//布局
	_wys += "nr {display: block;overflow: auto;}"//内容
	_wys += "pz {display: none;}"//配置
	_wys += "aj {display: inline-block;}"//按键
	_wys += "znbd {display: block;overflow: hidden;}"//配置

	try {
		wysJD.appendChild(document.createTextNode(_wys));
	} catch (ex) {
		wysJD.styleSheet.cssText = _wys;//针对IE
	}
	let head = document.getElementsByTagName("head")[0];
	head.appendChild(wysJD);
}

;
///<jscompress sourcefile="_tz.js" />
// [碎片]

//拓展  内模块
NWqd.prototype.tzNMK = function () {

    // NW01模块(工具)
    this._tz.tzFF(this.gj, "NW01");             //拓展工具

    // NW02模块(节点管理、nw节点)
    //在创建nw对象时，会动态检测、附加拓展的方法。
    this.tzJD.jiazaiPZdx(this._XT_PZ_TZ);

    // NW03模块(访问)
    this._tz.tzFF(this.ff, "NW03.rq");          //访问-容器
    this._tz.tzFF(this.ff.yc, "NW03.yc");       //访问-远程访问 
    this._tz.tzFF(this.ff.bd, "NW03.bd");       //访问-本地访问 

    // NW04模块 引擎
    this._tz.tzFF(this.yq, 'NW04.rq')
    this._tz.tzFF(this.yq.rw, 'NW04.rw')
    this._tz.tzFF(this.yq.jt, 'NW04.jt')
    this._tz.tzFF(this.yq.mb, 'NW04.mb')

    _tz = undefined;
}

//拓展  外模块
NWqd.prototype.tzWMK = function () {
    // NW01模块(工具)
    let _MKsz = this.mk.hqTZmk();
    let _TZsz;
    let _pz_lujing;
    let _pz_dx;
    for (let i = 0; i < _MKsz.length; i++) {
        //一个模块对象里面，有多个被拓展的 对象配置
        _TZsz = this.mk.hqTZmkPZ_dxSZ(_MKsz[i]);
        for (let i = 0; i < _TZsz.length; i++) {
            _pz_lujing = this.mk.hqTZmkPZ_lj(_TZsz[i]);
            _pz_dx = this.mk.hqTZmkPZ_dx(_MKsz[i], _TZsz[i]);
            if (!_pz_lujing) {
                console.error('===配置了拓展，但拓展配置中，没有配置参数lj===：')
                console.error(_TZsz[i])
                continue;
            }
            this._tz.tzFF(_pz_dx, _pz_lujing);
        }
    }
    // NW02模块(工具)
    this._tz = undefined;
}
;
///<jscompress sourcefile="NWqd_dy.js" />
function NWqd_dy(nr) {
    try {
        if (this.gj_hqMCdz('_NWPZ_KG_QD_DAYIN')) {//_配置_开关_打开_打印
            console.log(nr);
        }
    } catch (e) {
    }
};
///<jscompress sourcefile="NWqd_jb.js" />
/**
 * 启动模块——文档准备好后，自动执行
 */
function NWqd_jb() {
    //加载全局配置_拓展配置
    this.jiazai = function () {
        return this.gj_hqMCdz('NW_Tuozhan') ? NW_Tuozhan : null;
    }

    //启动:用户的方法——如果存在的话
    this.zx_nw_qd = function () {
        //如果存在默认初始化函数
        let ffSL = this.gj_hqMCdz('_NWPZ_CS_QDFFSL') ? parseInt(_NWPZ_CS_QDFFSL) : 10;
        let _nw_qd_mc;
        for (let i = 0; i < ffSL; i++) {
            _nw_qd_mc = '_xt_nw_qd' + i
            this.gj_zxHS(_nw_qd_mc, '...执行 ' + _nw_qd_mc + '() :')
        }
    }

    this.zx_nw_ck_cc = function () {
        this.gj_zxHS('_xt_nw_ck_cc');
    }

    //启动:用户的方法nw_jx——如果存在的话
    this.jx = function () {
        this.gj_zxHS('_xt_nw_jx', '...执行 _xt_nw_jx() :')
    }
    /**
     * 执行mz函数。
     * @param {文本} mz 函数名
     * @param {文本} dyxx 打印信息
     */
    this.gj_zxHS = function (mz, dyxx) {
        let ff = this.gj_hqMCdz(mz)
        if (ff) {
            if (dyxx) {
                this.dy(dyxx)
            }
            ff();
        }
    }
    /**
     * 获取名称地址。
     * 取得mz对应的内存空间入口地址。如果没有，返回null
     * @param {文本} mz 文本
     * @returns 入口地址|null
     */
    this.gj_hqMCdz = function (mz) {
        try {
            return eval(mz);//取nw_jx空间地址
        } catch (e) {
            return null;
        }
    }

    /**
     * 打印信息
     * @param {文本} nr 打印的内容
     */
    this.dy = NWqd_dy

}

;
///<jscompress sourcefile="kaishi.js" />
//窗口文档加载完成后，触发
window.onload = function () {
    let _TZ_;
    let i = 0;
    //1、实例NWqd_jb:ksDX
    let ksDX = new NWqd_jb();
    ksDX.dy('\n' + (i++) + '）已实例一个:【启动框架脚本】对象')

    //2、加载全局配置
    ksDX.dy('\n' + (i++) + '）加载【拓展配置】:')
    _TZ_ = ksDX.jiazai();

    //3、实例NWqd:nw
    nw = new NWqd(_TZ_);
    ksDX.dy('\n' + (i++) + '）已产生框架默认【使用对象】:nw')

    //4、
    if (_TZ_) {
        ksDX.dy('\n' + (i++) + '）nw-拓展【核心模块】方法:')
        nw.tzNMK();
    }

    //5、执行:nw 注册【功能模块】
    ksDX.dy('\n' + (i++) + '）开始检测 用户-【模块】:')
    if (ksDX.gj_hqMCdz('_xt_nw_zcMK')) {
        let _nw_zcMKJG = _xt_nw_zcMK();//启用外部方法，取得用户 返回值：[{外部模块对象1},{外部模块对象2}]
        if (_nw_zcMKJG) {
            ksDX.dy('...【注册模块】:')
            //缓存 功能模块对象
            nw.mk.GNMK = _nw_zcMKJG;
            //如果包含 任务配置，放一份到 任务管理中心去。
            nw.yq.tjRW(_nw_zcMKJG)
        }
    }

    //6、拓展【外部模块】方法
    if (_TZ_) {
        ksDX.dy('\n' + (i++) + '）nw-拓展【外部模块】方法:')
        nw.tzWMK();
    }

    //7、执行初始化动作
    ksDX.dy('\n' + (i++) + '）nw-启动:')
    nw.qd0();

    //8、容器_环境配置
    let _rqHJ = ksDX.gj_hqMCdz('_NWPZ_KG_RQ_HJPZ')
    if (null == _rqHJ || _rqHJ) {//没有配置，与配置值为真，都表示要 执行容器环境配置。
        ksDX.dy('\n' + (i++) + '）开始配置 容器环境样式')
        let _PZrq_hjCS = { wbj: '0px', nbj: '0px', g: '100%', k: '100%', overflow: 'hidden' }
        nw.gen.ys.xgNYS(_PZrq_hjCS) //默认实例 gen=【nw节点：html】  gen代表【根】  
        nw.st.ys.xgNYS(_PZrq_hjCS) //默认实例 st=【nw节点：html】   st代表 【身体】 
    }


    nw.ck.bj.stBJ();//对身体节点进行布局
    nw.ck.dw.stDW();
    nw.ck.bj.stBJ();//对身体节点进行布局
    nw.ck.dw.stDW();

    // setTimeout(function () {
    //     nw.ck.bj.stBJ();//对身体节点进行布局
    //     nw.ck.dw.stDW();
    //     setTimeout(arguments.callee, 200);
    // }, 200);

    //9、执行用户 _xt_nw_qd[0-n]的方法，如果有
    ksDX.dy('\n' + (i++) + '）开始检测 用户-【启动】方法')
    ksDX.zx_nw_qd();//执行 _xt_nw_qd[0-n] 方法

    //10、启动引擎
    ksDX.dy('\n' + (i++) + '）启动nw-引擎:')
    nw.qdYQ();

    //11、执行用户 _xt_nw_jx() 方法，如果有
    ksDX.dy('\n' + (i++) + '）开始检测 用户-【就绪】方法！')
    ksDX.jx();



    window.onresize = function () {
        nw.ck.bj.stBJ();
        nw.ck.dw.stDW();
        nw.ck.bj.stBJ();
        nw.ck.dw.stDW();

        ksDX.zx_nw_ck_cc();
        NW04_jt_fz_ck_gb();
    }

    //默认——关闭浏览器自带的右击菜单。因为没有任何意义。
    window.oncontextmenu = function () {
        try {
            if (eval('_NWPZ_KG_LLQ_YJCD')) {
                return true;
            }
            return false;
        } catch (e) {
            return false;
            // event.preventDefault()
        }
    };
}



;
///<jscompress sourcefile="NWHS_1.js" />
/**
 * 从ksJD开始，一直向上游寻找 【sxMing属性=sxZhi】的节点。如果到了 jzJD（截止节点），还没找到，返回null
 * @param {文本|对象} ksJD 原始节点_开始节点
 * @param {文本} sxMing 属性名
 * @param {文本|数字} sxZhi 属性值
 * @param {文本|对象} jzJD 原始节点_截止节点。如果为null，则表示body 
 * 
 */
function NWHS_hqJD_tgSXzhi(ksJD, sxMing, sxZhi, jzJD) {
	ksJD = NWHS_hqJD(ksJD);
	// console.log(ksJD)
	jzJD = jzJD ? NWHS_hqJD(jzJD) : document.getElementsByTagName('body')[0];
	if (NWHS_pdJDSX(ksJD, sxMing, sxZhi)) {
		return ksJD;
	}
	if (ksJD == jzJD) {
		return null;
	}
	while (ksJD = ksJD.parentNode) {
		if (NWHS_pdJDSX(ksJD, sxMing, sxZhi)) {
			return ksJD;
		}
		if (ksJD == jzJD) {
			return null;
		}
	}
	return null;
}

function NWHS_hqJD_tgSX(ksJD, sxMing, jzJD) {
	ksJD = NWHS_hqJD(ksJD);
	jzJD = jzJD ? NWHS_hqJD(jzJD) : document.getElementsByTagName('body')[0];
	if (ksJD.getAttributeNode(sxMing)) {
		return ksJD;
	}
	if (ksJD == jzJD) {
		return null;
	}
	while (ksJD = ksJD.parentNode) {
		if (ksJD.getAttributeNode(sxMing)) {
			return ksJD;
		}
		if (ksJD == jzJD) {
			return null;
		}
	}
	return null;
}

/**
 * 判断 节点的【sxMing属性】，值是不是等于sxZhi
 * 真：等于
 * 假：不等于 
 * @param {对象} ksJD 节点
 * @param {文本} sxMing 属性名
 * @param {文本|数字} sxZhi 属性值
 * @returns 真|假
 */
function NWHS_pdJDSX(ksJD, sxMing, sxZhi) {
	// console.log(ksJD)
	let _sx = ksJD.getAttributeNode(sxMing);
	return _sx && _sx.value == sxZhi;
}

function NWHS_hqJD(zhi) {
	if (typeof zhi == 'string') {
		return document.getElementById(zhi);
	}
	else if (zhi.Jiedian) {
		return zhi.Jiedian;
	} else {//传入的是普通的节点的对象
		return zhi;
	}
}

/**
 * 删除两边的空。
 * @param {文本} nr 内容
 * @param {真|假} schhf 真=删除换行符。假=不动（默认）
 */
function NWHS_sck(nr, schhf) {
	if (nr) {
		return schhf ? nr.replace(/(^\s*)|(\s*$)|([\r\n]*)/g, "") : nr.replace(/(^\s*)|(\s*$)/g, "")
	}
}




//获取即可时间
function NWHS_hqJKshijian() {
	let _SJ = new Date();
	return _SJ.getFullYear() + "年"
		+ (_SJ.getMonth() + 1) + "月"
		+ _SJ.getDate() + "日  "
		+ NWHS_hqJKshijian_ngj(_SJ.getHours()) + ":" + NWHS_hqJKshijian_ngj(_SJ.getMinutes()) + ":" + NWHS_hqJKshijian_ngj(_SJ.getSeconds());
}

function NWHS_hqJKshijian_ngj(val) {
	if (val < 10) {
		return ("0" + val);
	}
	else {
		return (val);
	}
};
///<jscompress sourcefile="NW04_zdy_ys.js" />
function NW04_zdy_ys(fq) {
    this.dh = new NW04_zdy_ys_dh();
    this.gtGC = new NW04_zdy_ys_gtGC(this.dh)
    this.nw = fq.nwDX;
}


//获取个体
NW04_zdy_ys.prototype.cj = function (jd) {
    return this.gtGC.hqGT(jd)
}

NW04_zdy_ys.prototype.yyGTys = function (gt, nwJD) {
    if (gt) {
        
        nwJD.ys.xgNYS(gt.ysCS);
        // console.log(gt.ysCS)
        // console.log(nwJD.Jiedian)
    }
}

NW04_zdy_ys.prototype.yyGTnr = function (gt, nwJD) {
    if (!NWHS_sck(nwJD.jd.hqNR_html(), 1) && gt.nr) {
        nwJD.jd.xgNR(gt.nr)
    }
}
;
///<jscompress sourcefile="NW04_zdy_ys_dh.js" />
// 代号=样式
// 参数：【样式代号表】
function NW04_zdy_ys_dh() {
    //默认的
    this.gg_ys = { zt_ys: 'red' }
    //指定某类标签的  
    // this.AJ = {
    //     tj: { zt_ys: '#3124e4', g: '27px', k: '70px', gd: 'hidden', nr: '【添加】' },//添加
    //     bc: { zt_ys: '#3124e4', g: '27px', k: '70px', gd: 'hidden', nr: '【保存】' },//添加
    //     sc: { zt_ys: 'red', g: '27px', k: '70px', gd: 'hidden', nr: '【删除】' },
    //     xg: { zt_ys: '#CC00FF', g: '27px', k: '70px', gd: 'hidden', nr: '【修改】' },
    //     sx: { zt_ys: 'green', g: '27px', k: '70px', gd: 'hidden', nr: '【查询】' },
    // }

    this.AJ = {
        tj: { zt_ys: '#3124e4', g: '27px', gd: 'hidden', nr: '【添加】' },//添加
        bc: { zt_ys: '#3124e4', g: '27px', gd: 'hidden', nr: '【保存】' },//添加
        sc: { zt_ys: 'red', g: '27px', gd: 'hidden', nr: '【删除】' },
        xg: { zt_ys: '#CC00FF', g: '27px', gd: 'hidden', nr: '【修改】' },
        sx: { zt_ys: 'green', g: '27px', gd: 'hidden', nr: '【查询】' },
    }
}


NW04_zdy_ys_dh.prototype.hqYS = function (jdM, dm) {
    if (!dm) {
        return this[jdM];
    }
    if (!jdM) {
        return this[dm];
    }
    //jdM与 dm都不为假：
    let ys;
    //ys为节点专用配置
    if ((ys = this[jdM])) {
        if (ys[dm]) { //节点内，某一个属性值  = this.AJ.tj
            return ys[dm];
        }
        return this[dm];  //采用全局的变量。
    }
}

;
///<jscompress sourcefile="NW04_zdy_ys_gt.js" />

// 给一个节点（原始或nw节点），即可以自动分析出来 。ys属性 的样式代号。
function NW04_zdy_ys_gtGC(dhk) {
    this.dhk = dhk;// new NW04_zdy_ys_dh(); //, dhk
}


function NW04_zdy_ys_gt(jd) {
    this.jd = jd;
    this.nr = null;
    this.ysCS = {};//样式参数。用户自己的配置。
}
NW04_zdy_ys_gt.prototype.tj = function (ming, zhi) {
    this.ysCS[ming] = zhi;
}
NW04_zdy_ys_gt.prototype.tjDH = function (dx) {
    if (dx) {
        for (let ming in dx) {
            if (ming == 'nr') {
                // if (!this.nr) {//没指定内容时，可以录入内容
                this.nr = dx[ming];
                // }
                continue;
            }
            if (this.ysCS[ming]) {
                continue;
            }
            this.tj(ming, dx[ming])
        }
    }
}

//分析样式。封装在 样式个体中。
NW04_zdy_ys_gtGC.prototype.hqGT = function (jd) {
    let cs;
    let _sx = jd.getAttributeNode('ys');
    let yscs;
    if (_sx) {
        cs = NWHS_sck(_sx.value)
        if (cs) {
            let jdBQming = jd.nodeName;
            yscs = new NW04_zdy_ys_gt(jd);
            if (cs.indexOf(',') == -1) {
                yscs.tjDH(this.dhk.hqYS(jdBQming, cs))
            } else {
                cs = cs.split(',');
                let cs1;
                for (let i = 0; i < cs.length; i++) {
                    // 样式代号 一定不包含=号。
                    if ((cs1 = NWHS_sck(cs[i]))) {
                        if (cs1.indexOf('=') == -1) {
                            //这里是【样式代号】的样式
                            yscs.tjDH(this.dhk.hqYS(jdBQming, cs1))
                        } else {
                            //包含=。表示【参数=值】
                            cs1 = cs1.split('=');
                            cs1[0] = NWHS_sck(cs1[0])
                            if (cs1[0]) {
                                cs1[1] = NWHS_sck(cs1[1]);
                                if (cs1[0] == 'nr') {
                                    yscs.nr = cs1[1];//用户配置的内容，强制写入。
                                    continue;
                                }
                                yscs.tj(cs1[0], (cs1[0] == 'k' || cs1[0] == 'g') && /^[0-9.]+$/.test(cs1[1]) ? cs1[1] + 'px' : cs1[1])
                            }
                        }
                    }
                }
            }
        }
    }
    _sx = jd.getAttributeNode('nr');
    if (_sx) {
        if (!yscs) {
            yscs = new NW04_zdy_ys_gt(jd);
        }
        yscs.nr = _sx.value
    }
    return yscs;
};
///<jscompress sourcefile="NW04_zdy_sj.js" />

// 给一个节点（原始或nw节点），即可以自动分析出来 。ys属性 的样式代号。
function NW04_zdy_sj() {
    this.hc = [];

}

NW04_zdy_sj.prototype.cj = function (jd) {
    let gt = new NW04_zdy_sj_gt(jd);
    if (gt.sj) {
        this.hc.push(gt)
        return gt;
    }
    return null;
}


// NW04_zdy_sj.prototype.sc = function (jd) {
//     for (let i = 0; i < hc.length; i++) {
//         if (hc[i].jd == jd) {
//             this.hc[i].sc();
//             this.hc.splice(i, 1);//从数组删除   
//         }
//     }
// }

NW04_zdy_sj.prototype.sc = function (jd) {
    let _NWerziM = jd.children;
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].jd == jd) {
            this.hc[i].sc();
            this.hc.splice(i, 1);//从数组删除   
        }
    }
    for (let i = 0; i < _NWerziM.length; i++) {
        switch (_NWerziM[i].nodeName) {
            case 'SCRIPT':
            case 'STYLE':
                continue;
        }
        this.sc(_NWerziM[i]);
    }
}

NW04_zdy_sj.prototype.zx = function (jd, sjDH, e) {
    let sj = e;
    let s = e;
    let djjd = e.target;
    let jd2 = e.target;
    for (let i = 0; i < this.hc.length; i++) {
        if (this.hc[i].jd == jd && this.hc[i][sjDH]) {
            eval(this.hc[i][sjDH])
        }
    }
}


function NW04_zdy_sj_sb_ax(e) {
    nw.yq.zdy.sj.zx(this, 'sb_ax', e)
}
function NW04_zdy_sj_sb_sk(e) {
    nw.yq.zdy.sj.zx(this, 'sb_sk', e)
}
function NW04_zdy_sj_sb_dj(e) {
    nw.yq.zdy.sj.zx(this, 'sb_dj', e)
}
function NW04_zdy_sb_sb_sj(e) {
    nw.yq.zdy.sj.zx(this, 'sb_sj', e)
}
function NW04_zdy_sj_sb_yj(e) {
    nw.yq.zdy.sj.zx(this, 'sb_yj', e)
}
function NW04_zdy_sj_sb_jr(e) {
    nw.yq.zdy.sj.zx(this, 'sb_jr', e)
}
function NW04_zdy_sj_sb_lk(e) {
    nw.yq.zdy.sj.zx(this, 'sb_lk', e)
}

function NW04_zdy_sj_jp_ax(e) {
    nw.yq.zdy.sj.zx(this, 'jp_ax', e)
}
function NW04_zdy_sj_jp_az(e) {
    nw.yq.zdy.sj.zx(this, 'jp_az', e)
}
function NW04_zdy_sj_jp_sk(e) {
    nw.yq.zdy.sj.zx(this, 'jp_sk', e)
}
function NW04_zdy_sj_z_gb(e) {
    nw.yq.zdy.sj.zx(this, 'z_gb', e)
}

function NW04_zdy_sj_z_sr(e) {
    nw.yq.zdy.sj.zx(this, 'z_sr', e)
}
function NW04_zdy_sj_gdt_gd(e) {
    nw.yq.zdy.sj.zx(this, 'gdt_gd', e)
}
;
///<jscompress sourcefile="NW04_zdy_sj_gt.js" />

// 给一个节点（原始或nw节点），即可以自动分析出来 。ys属性 的样式代号。
function NW04_zdy_sj_gt(jd) {
    this.jd = jd;
    this.sj = 0;
    this.sb_ax;//事件。单击事件
    this.sb_sk;//事件。
    this.sb_dj;//事件。
    this.sb_sj;//事件。
    this.sb_yj;//事件。
    this.sb_jr;//事件。
    this.sb_lk;//事件。
    this.jp_ax;
    this.jp_az;
    this.jp_sk;
    this.z_gb;
    this.z_sr;
    this.gdt_gd;

    //鼠标
    this._ngj_zc('onmousedown', NW04_zdy_sj_sb_ax, 'sb_ax')
    this._ngj_zc('onmouseup', NW04_zdy_sj_sb_sk, 'sb_sk')
    this._ngj_zc('onclick', NW04_zdy_sj_sb_dj, 'sb_dj')
    this._ngj_zc('ondblclick', NW04_zdy_sb_sb_sj, 'sb_sj')
    this._ngj_zc('oncontextmenu', NW04_zdy_sj_sb_yj, 'sb_yj')
    this._ngj_zc('onmouseover', NW04_zdy_sj_sb_jr, 'sb_jr')
    this._ngj_zc('onmouseout', NW04_zdy_sj_sb_lk, 'sb_lk')

    //键盘
    this._ngj_zc('onkeydown', NW04_zdy_sj_jp_ax, 'jp_ax')
    this._ngj_zc('onkeypress', NW04_zdy_sj_jp_az, 'jp_az')
    this._ngj_zc('onkeyup', NW04_zdy_sj_jp_sk, 'jp_sk')

    // 值 变动事件
    this._ngj_zc('onchange', NW04_zdy_sj_z_gb, 'z_gb')
    this._ngj_zc('oninput', NW04_zdy_sj_z_sr, 'z_sr')

    // 滚动条-滚动事件
    this._ngj_zc('onscroll', NW04_zdy_sj_gdt_gd, 'gdt_gd')

}
NW04_zdy_sj_gt.prototype.sc = function () {
    this._ngj_sc('onmousedown')
    this._ngj_sc('onmouseup')
    this._ngj_sc('onclick')
    this._ngj_sc('ondblclick')
    this._ngj_sc('oncontextmenu')
    this._ngj_sc('onmouseover')
    this._ngj_sc('onmouseout')

    this._ngj_sc('onkeydown')
    this._ngj_sc('onkeypress')
    this._ngj_sc('onkeyup')

    this._ngj_sc('onchange')
    this._ngj_sc('oninput')
    this._ngj_sc('onscroll')
}


NW04_zdy_sj_gt.prototype._ngj_sc = function (nwjtFF) {
    this.jd[nwjtFF] = null
}


NW04_zdy_sj_gt.prototype._ngj_zc = function (nwjtFF, ff, sxMing) {
    let _sx = this.jd.getAttributeNode(sxMing);
    if (_sx) {
        this.jd[nwjtFF] = ff
        this[sxMing] = _sx.value.indexOf('(') == -1 ? _sx.value + '()' : _sx.value
        this.sj = 1;
    }
}


;
///<jscompress sourcefile="NW04_zdy.js" />

// 给一个节点（原始或nw节点），即可以自动分析出来 。ys属性 的样式代号。
function NW04_zdy(fq) {
    this.nwDX = fq.fq;
    this.fq = fq;

    this.sj = new NW04_zdy_sj(this)
    this.ys = new NW04_zdy_ys(this)
    this.bq = new NW04_zdy_bq(this)
}

NW04_zdy.prototype.qd0 = function () {
    this.zx(this.nwDX.st.Jiedian)
}

/**
 * 对jd内进行布局.调整儿子 
 * @param {对象} nwJD nw封装的节点对象
 */
NW04_zdy.prototype.zx = function (jd) {
    let _NWerziM = jd.children;
    let ez1;
    let ysGT;
    let nwJD;
    for (let i = 0; i < _NWerziM.length; i++) {
        ez1 = _NWerziM[i];
        switch (ez1.nodeName) {
            case 'SCRIPT':
            case 'STYLE':
                continue;
        }
        ysGT = this.ys.cj(ez1);
        // 特殊：针对 AJ标签，可能没有样式。即，ysGT 为null的情况。
        if (ez1.nodeName == 'AJ') {
            nwJD = this.nwDX.cj2(ez1)
            this.bq.cj(nwJD, ysGT);
            continue;
        }

        if (ysGT) {
            nwJD = this.nwDX.cj2(ez1)
            this.ys.yyGTys(ysGT, nwJD);
            this.ys.yyGTnr(ysGT, nwJD);

        }
        this.sj.cj(ez1)

        this.zx(ez1);
    }
}

NW04_zdy.prototype.zx1 = function (jd) {
    let _NWerziM = jd.children;
    let ez1;
    let ysGT;
    let nwJD;
    for (let i = 0; i < _NWerziM.length; i++) {
        ez1 = _NWerziM[i];
        switch (ez1.nodeName) {
            case 'SCRIPT':
            case 'STYLE':
                continue;
        }
        ysGT = this.ys.cj(ez1);
        if (ysGT) {
            console.log(ysGT.jd)
            console.log(ysGT.ysCS)
            nwJD = this.nwDX.cj2(jd)
            this.ys.yyGTys(ysGT, nwJD);
            this.ys.yyGTnr(ysGT, nwJD);
        }
        this.sj.cj(ez1)
    }
};
///<jscompress sourcefile="NW04_zdy_bq.js" />

function NW04_zdy_bq(fq) {
    this.nw = fq.nwDX;
    this.ys = fq.ys;
    this.sj = fq.sj;
}
NW04_zdy_bq.prototype.cj = function (nwJD, ysGT) {
    if (ysGT) {
        this.ys.yyGTys(ysGT, nwJD);
    }
    let jd = nwJD.Jiedian;
    this.sj.cj(jd)
    this.aj(jd, ysGT);
}

NW04_zdy_bq.prototype.aj = function (jd, ysGT) {
    // console.log(jd)
    let cs = '';
    if (ysGT) {
        if (ysGT.ysCS.g) {
            cs = 'height:' + ysGT.ysCS.g + ';'
        }
        if (ysGT.ysCS.k) {
            cs += 'width:' + ysGT.ysCS.k + ';'
        }
        if (ysGT.ysCS.zt_ys) {
            cs += 'color:' + ysGT.ysCS.zt_ys + ';'
        }
    }
    if (cs) {
        cs = 'style="' + cs + '"';
    }

    let nr = this._ngj_hqBQnr(jd);
    if (!nr && ysGT) {
        nr = ysGT.nr;
    }
    jd.innerHTML = '<button ' + cs + '>' + nr + '</button>';
    // console.log(jd.innerHTML)
}

NW04_zdy_bq.prototype._ngj_hqBQnr = function (jd) {
    if (jd.children.length == 0) {
        let jdNR = NWHS_sck(jd.innerHTML, 1)
        if (jdNR) {
            return jdNR;
        }
    }

};
///<jscompress sourcefile="NW06.js" />
//智能表单
function NW06(fq) {
    //nw
    this.nw = fq;
    this.bds = new NW06_jyk()

    //智能表单里面的按键对象
    this.znbd = [];
}

NW06.prototype.qd0 = function () {
    //不包含body节点本身
    this.ngj_zc(this.nw.st.Jiedian);
}
/**
 * 对jd内进行布局.调整儿子 
 * @param {对象} nwJD nw封装的节点对象
 */
NW06.prototype.ngj_zc = function (jd) {
    let _sx = jd.getAttributeNode('znbd');
    if (_sx) {
        this.cj(jd)
        return;
    }
    let _NWerziM = jd.children;
    let ez1;
    for (let i = 0; i < _NWerziM.length; i++) {
        ez1 = _NWerziM[i];
        switch (ez1.nodeName) {
            case 'BJ':
            case 'BUJU':
            case 'NR':
            case 'DIV':
                this.ngj_zc(ez1);
        }
    }
}


//节点
NW06.prototype.cj = function (jd) {
    let gt = this.hq(jd);
    if (gt) {
        return gt;
    }
    gt = new NW06_gt(this.nw, this.nw.cj2(jd));
    this.znbd.push(gt);
    return gt;
}

//优先角色。找不到角色，再找id
NW06.prototype.hq = function (jd_znbd) {
    if (typeof jd_znbd == 'string') {
        let gt = this.ngj_hqGT('znbd', NWHS_sck(jd_znbd))
        if (gt) {
            return gt;
        }
        jd_znbd = document.getElementById(jd_znbd);
    }
    return this.ngj_hqGT('jd', jd_znbd)
}



NW06.prototype.ngj_hqGT = function (hc_ming, zhi) {
    for (let i = 0; i < this.znbd.length; i++) {
        if (this.znbd[i][hc_ming] == zhi) {
            return this.znbd[i];
        }
    }
};
///<jscompress sourcefile="NW06_gt.js" />
// 智能表单 个体配置中，可以配置默认值。
// 然后，判断初始化地址，如果存在，加载初始化值（比如，修改，从服务器访问取数据）
function NW06_gt(nw, nwDJ) {
    this.nw = nw;
    this.nwJD = nwDJ;
    this.jd = nwDJ.Jiedian;               
    this.znbd = this.hqZnbd()
    this.zt = 0;//表单状态，0=校验不通过；1=检验通过;

    //智能表单的节点集合
    this.jdM = [];
    this._ngj_hqKJ(this.jd);

    //表单里面的控件
    this.kjM = [];
    this.pz = null;
    //表单的数据保存在哪里（服务器后台）
    this.yc_dizhi;
    //从远程内容中，提取数据的关键词（属性名）
    this.yc_shuju_dizhi = 'dizhi';      //表单的数据要提交到哪个服务器路径 
    this.yc_shuju_cs = 'cs';            //附上的参数
    this.yc_shuju_gt = 'gt';            //个体参数 默认值、校验规则、提示信息、 如果控件是文件，还包括 上传文件的路径
    this.yc_shuju_kj_dizhi = 'kj_dizhi' //针对【控件】的文件上传的地址。

    this.zdc = nw.ck.tcc.dedai('正在准备，请稍后......', this.nwJD, 1);//锁屏body
    this.sj = null;//在方法 _03yc_qq_cg 里面初始化 new NW06_gt_sj(this);

    this.qd0()
}

//点击上传按键时，会自动调用这个方法
NW06_gt.prototype.sq = function () {
    this.zdc.xs()
}

//点击重置按键时，会自动调用这个方法
NW06_gt.prototype.cz = function () {

}

NW06_gt.prototype.qd0 = function () {
    let pz = this._ngj_hqSXzhi('pz');
    if (pz) {
        this.jiazaiPZ(eval(pz));
    } else {
        pz = this._ngj_hqSXzhi('pz2');
        if (pz) {
            let fwfs = this._ngj_hqSXzhi('fwfs');
            this.jiazaiPZ(pz, fwfs ? fwfs : 'get');
        }
    }
}

/**
 * 1、加载配置
 * @param {文本|对象} dizhi_dx 地址|对象
 * @param {文本} fwfs 访问方式。当是远程请求时，可以通过 此参数，控制 post(默认) 还是get
 */
NW06_gt.prototype.jiazaiPZ = function (dizhi_dx, fwfs) {
    if (typeof dizhi_dx == "object") {
        this.pz = dizhi_dx;
        this._03yc_qq_cg(this.pz);
    } else {
        if (!fwfs) {
            fwfs = 'post';
        }
        if (fwfs == 'post') {
            this.nw.ff.yc.by_j(dizhi_dx, null, this)
        } else {
            this.nw.ff.yc.n_j(dizhi_dx, null, this)
        }
    }
}

//远程加载到的配置文件.开始初始化
NW06_gt.prototype._03yc_qq_cg = function (jg) {
    if (!jg) {
        return;
    }
    this.pz = jg;
    let gt = jg[this.yc_shuju_gt];
    let kjpz;
    let kjlx;

    let kjJD;
    if (gt) {
        for (let i = 0; i < gt.length; i++) {
            kjpz = gt[i];   //找到控件配置了
            kjlx = this._ngj_hqJKlx_tgMC(kjpz.bh);
            kjJD = this._ngj_hqJD_tgMC(kjpz.bh, kjlx)
            if (kjJD) {
                this.kjM.push(new NW06_kj_gt(this, kjJD, kjlx, kjpz))
            }
        }
    }
    this.sj = new NW06_gt_sj(this);
    // this.zdc.xs()
}

/**
 * 内工具，通过名称，取得指定范围内的 节点的类型。
 * @param {文本} mc 节点名称
 * @returns 节点类型|null————没找到节点时类型或不支持该类型
 */
NW06_gt.prototype._ngj_hqJKlx_tgMC = function (mc) {
    let ez1;
    let kjlx;
    for (let i = 0; i < this.jdM.length; i++) {
        ez1 = this.jdM[i];
        if (this._ngj_hqMC(ez1) == mc) {
            kjlx = this._ngj_hqKJlx(ez1);
            if (kjlx) {
                return kjlx;
            }
        }
    }
    return null;
}

/**
 * 内工具，通过名称，取得指定范围内的 节点
 * @param {文本} mc 节点名称
 * @param {文本} lx 节点类型
 * @returns 节点|节点数组|null————没找到节点时
 */
NW06_gt.prototype._ngj_hqJD_tgMC = function (mc, lx) {
    let jg = [];
    let ez1;
    for (let i = 0; i < this.jdM.length; i++) {
        ez1 = this.jdM[i];
        if (this._ngj_hqMC(ez1) == mc) {
            if (lx == 'fxk' || lx == 'dxk') {
                jg.push(ez1);
            } else {
                return this.nw.cj2(ez1);
            }
        }
    }
    return jg.length == 0 ? null : jg;
}

/**
 * 获取控件类型
 * @param {对象} jd 节点
 * @returns 控件类型
 */
NW06_gt.prototype._ngj_hqKJlx = function (jd) {
    switch (jd.nodeName) {
        //value 输入类型的控件
        case 'INPUT':
            let _sx = jd.getAttributeNode('type');
            if (!_sx) {
                return 'wb';
            }
            switch (_sx.value.toLowerCase()) {
                case 'hidden'://文本类型
                case 'text'://文本类型
                    return 'wb';
                case 'file'://文件类型
                    return 'wj';
                case 'checkbox':
                    return 'fxk';
                case 'radio':
                    return 'dxk';
                case 'image':
                    return 'tp';
            }
            return null;
        case 'TEXTAREA':
            return 'wby';
        case 'IMG':
            return 'tp';
        case 'AUDIO':
            return 'yp';
        case 'SELECT':
            return 'xlk';
    }
    //取不到类型的，表示不支持的控件
    return null;
}

/**
 * 通过递归获取 表单控件
 * @param {对象} jd 节点
 */
NW06_gt.prototype._ngj_hqKJ = function (jd) {
    let _ErziM = jd.children;
    for (let i = 0; i < _ErziM.length; i++) {
        switch (_ErziM[i].nodeName) {
            case 'fjcs':
            case 'PZ':
                continue;
            case 'AJ':
            case 'BUTTON':
            case 'INPUT':
            case 'TEXTAREA':
            case 'IMG':
            case 'AUDIO':
            case 'SELECT':
                this.jdM.push(_ErziM[i]);
                continue;
        }
        this._ngj_hqKJ(_ErziM[i]);//检测他的儿子.
    }
}

/**
 * 获取 节点的【名称属性】
 * @param {对象} jd 原始节点
 * @returns 属性
 */
NW06_gt.prototype._ngj_hqMCSX = function (jd) {
    let _sx = jd.getAttributeNode('name');
    if (!_sx) {
        _sx = jd.getAttributeNode('mc');
    }
    return _sx;
}



/**
 * 获取 节点的【属性值】
 * @param {对象} jd 原始节点
 * @returns 属性
 */
NW06_gt.prototype._ngj_hqSXzhi = function (ming) {
    let _sx = this.jd.getAttributeNode(ming);
    if (_sx) {
        return NWHS_sck(_sx.value)
    }
    return null;
}

/**
 * 获取 节点的 名字-自动除两边空。
 * @param {对象} jd 原始节点
 * @returns 名字-自动除两边空。
 */
NW06_gt.prototype._ngj_hqMC = function (jd) {
    let _sx = this._ngj_hqMCSX(jd)
    return _sx ? NWHS_sck(_sx.value) : '';
}

NW06_gt.prototype.hqZnbd = function () {
    return this._ngj_hqSXzhi('znbd');
    // let _sx = this.jd.getAttributeNode('znbd');
    // if (_sx) {
    //     return NWHS_sck(_sx.value)
    // }
    // return null
}
;
///<jscompress sourcefile="NW06_jyk.js" />
//智能表单
function NW06_jyk() {

    //直接、完整的表达式。直接用
    this.lujing0 = /^[\D\d]*$/;
    this.lujing1 = /^[\D\d]{1,300}$/;
    this.dh01 = /^(0|1){1}$/;
    this.dh012 = /^(0|1|2){1}$/;

    //自动加【 ^前缀 】，拼接正则表达式时，会自动追加【 $结尾 】————如果不存在的话
    this.__bds = {
        zh: "\\w",
        // 中文
        zw: "[\u4E00-\u9FA5]",
        // 内容
        nr: "[\\D\\d]",
        // 正整数
        sz_zzs: "[0-9]",
        // 整数
        sz_zs: "-?[0-9]",
        //路径类的
        lujing: "[\\D\\d]",
    }
}

NW06_jyk.prototype.hq = function (sxMing) {
    if (!sxMing) {
        return null;
    }

    sxMing = sxMing.replace(/\s+/g, "")
    let bds = this[sxMing];

    if (bds) {
        return typeof bds == 'string' ? new RegExp(bds) : bds;
    }

    if (/^\w+[*+?]{1}$/.test(sxMing)) {     //  nr*   nr+     nr?
        return this._hqBDS2(sxMing)
    }

    if (/^\w+{\d*,?\d*}$/.test(sxMing)) {    // nr{2,3}  nr{0,3}  nr{3,0}
        return this._hqBDS2(sxMing, 1)
    }
}

//针对：   nr*   nr+     nr?     nr{3,0}  nr{0,3}  nr{2,3}
NW06_jyk.prototype._hqBDS2 = function (sxMing, fh) {
    let yb = fh ? sxMing.lastIndexOf('{') : sxMing.length - 1
    return this._hqbds(sxMing.substring(0, yb), sxMing.substring(yb));
}

//取表达式
NW06_jyk.prototype._hqbds = function (ming, cd) {
    let bds = this.__bds[ming]
    if (bds) {
        return this._pj(bds, cd);
    }
}

//拼接
NW06_jyk.prototype._pj = function (bds, cd) {
    return new RegExp("^" + bds + cd + "$");
}
;
///<jscompress sourcefile="NW06_kj_gt.js" />
function NW06_kj_gt(fq, nwJD, lx, pz) {
    this.fq = fq;
    this.nw = fq.nw;
    this.wgj = this.nw.gj;

    this.kj_lx = lx;        // 控件类型。文本框=wb ；  文本域=wby ；  复选框=fxk ； 单选框=dxk ； 下拉框=xlk ； 图片=tp；文件=wj ；音频=yp
    this.kj_mc = pz.bh      // 控件名字。等于 namen属性值

    this.nwJD = nwJD;//// 复选框=fxk ； 单选框=dxk   = [];
    this.pz = pz;//在加载配置后，被外部附值
    this.mrz()
}

NW06_kj_gt.prototype.mrz = function () {
    if (this.pz.mrz) {
        this.z(this.pz.mrz)
    }
}



// 判断 代号（名称，name）是否与控件一样
NW06_kj_gt.prototype.pdMC = function (mc) {
    return this.kj_mc == mc
}

// 取得控件的值，或设置控件的值
NW06_kj_gt.prototype.z = function (zhi, zt) {
    let zhi_null = null == zhi
    switch (this.kj_lx) {
        case 'wb':      //文本
        case 'wby':     //文本域
        case 'yp':      //音频
        case 'xlk':     //下拉框
        case 'tp':      //图片
        case 'wj':      //文件
            return this.nwJD.z.zhi(zhi);    //设置值；当    zz=null  时，表示  取值。
    }
    //单选框或复选框时
    if (this.kj_lx == 'fxk' || this.kj_lx == 'dxk') {
        if (zhi_null) {
            return this.wgj.hqZT_fxk_dxk(this.nwJD, true);
        }
        if (null == zt) {
            zt = true;
        }
        if (this.kj_lx == 'fxk') {
            this.wgj.szZT_fxk(this.nwJD, zhi, zt);
        } else {
            this.wgj.szZT_dxk(this.nwJD, zhi, zt);
        }
        return
    }
}

NW06_kj_gt.prototype.jy = function (dizhi) {
    if (this.zzbds.test(dizhi)) {
        return true;
    }
    if (!this.zzbds) {//没有
        return true;
    }
}
;
///<jscompress sourcefile="NW06_gt_sj.js" />
// 智能表单 个体配置中，可以配置默认值。
// 然后，判断初始化地址，如果存在，加载初始化值（比如，修改，从服务器访问取数据）
function NW06_gt_sj(fq) {
    this.fq = fq;
    this.jdM = fq.jdM;
    //按键代号
    this.dh_tj = 'sq';
    this.dh_cz = 'cz';
    //
    this.qd0(fq.jdM)
}

function NW06_gt_sj_sq() {
    nw.znbd.hq(NWHS_hqJD_tgSX(this, 'znbd')).sq();
}

function NW06_gt_sj_cz() {
    nw.znbd.hq(NWHS_hqJD_tgSX(this, 'znbd')).cz();
}

NW06_gt_sj.prototype.qd0 = function (jdM) {
    for (let i = 0; i < jdM.length; i++) {
        this._ngj_zcsj(jdM[i]);
    }
}

/**
 * 获取 节点的【名称属性】
 * @param {对象} jd 原始节点
 * @returns 属性
 */
NW06_gt_sj.prototype._ngj_zcsj = function (jd) {
    let _sx = jd.getAttributeNode('ajlb');//ajlb='tcc_gb'
    if (_sx) {
        let dh = NWHS_sck(_sx.value).toLowerCase();
        jd.onclick = (dh == 'cz' ? NW06_gt_sj_cz : NW06_gt_sj_sq);
    }
}

;
